Input:
# ABC150 D

si = lambda: input()

ni = lambda: int(input())

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

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

from math import gcd

from math import ceil

def lcm(x, y):

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

n,m=nm()

a=nl()

ans=0

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

lcm_v=a[0]

for i in range(n):

    lcm_v=lcm(lcm_v,a[i])

ok_flg=[(lcm_v//i)%2==1 for i in a]

if all(ok_flg):

    ans=((m//lcm_v)+1)//2

print(ans)

# ĠABC 1 5 0 ĠD ĊĊ si Ġ= Ġlambda : Ġinput ()ĊĊ ni Ġ= Ġlambda : Ġint (input ())ĊĊ nm Ġ= Ġlambda : Ġlist (map (int , Ġinput (). split ()))ĊĊ nl Ġ= Ġlambda : Ġlist (map (int , Ġinput (). split ()))ĊĊ from Ġmath Ġimport Ġgcd ĊĊ from Ġmath Ġimport Ġceil ĊĊ def Ġlcm (x , Ġy ):ĊĊ ĠĠĠ Ġreturn Ġ( x Ġ* Ġy ) Ġ// Ġgcd (x , Ġy )ĊĊ n ,m = nm ()ĊĊ a = nl ()ĊĊ ans = 0 ĊĊ a =[ x // 2 Ġfor Ġx Ġin Ġa ] ĠĊĊĊĊ l cm _v =a [ 0 ]ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġlcm _v =l cm (l cm _v ,a [i ])ĊĊ ok _flg =[ ( l cm _v // i )% 2 == 1 Ġfor Ġi Ġin Ġa ]ĊĊ if Ġall (ok _flg ):ĊĊ ĠĠĠ Ġans =(( m // l cm _v )+ 1 )// 2 ĊĊ print (ans )ĊĊĊ


Input:
def main():

    while True:

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

        pattern = 0

        if n == x == 0:

            break

        else:

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

                for b in range(1, a):

                    for c in range(1, b):

                        pattern += 1 if a + b + c == x and a > b > c else 0

            print(pattern)

if __name__ == '__main__':

    main()

def Ġmain (): ĊĊĊĊ ĠĠĠ Ġwhile ĠTrue :ĊĊ ĠĠĠĠĠĠĠ Ġn , Ġx Ġ= Ġtuple (map (int , Ġinput (). split ()))ĊĊ ĠĠĠĠĠĠĠ Ġpattern Ġ= Ġ 0 ĊĊĊĊ ĠĠĠĠĠĠĠ Ġif Ġn Ġ== Ġx Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġa Ġin Ġrange ( 1 , Ġn + 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġb Ġin Ġrange ( 1 , Ġa ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġc Ġin Ġrange ( 1 , Ġb ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġpattern Ġ+= Ġ 1 Ġif Ġa Ġ+ Ġb Ġ+ Ġc Ġ== Ġx Ġand Ġa Ġ> Ġb Ġ> Ġc Ġelse Ġ 0 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (pattern )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ ĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()Ċ


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

numbers = list(range(A, B+1))

count = 0

for i in numbers:

    m = str(i)

    rm = ''.join(list(reversed(m)))

    if m == rm:

        count += 1

print(count)

A , ĠB Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ numbers Ġ= Ġlist (range (A , ĠB + 1 ))ĊĊ count Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġnumbers :ĊĊ ĠĠĠ Ġm Ġ= Ġstr (i )ĊĊ ĠĠĠ Ġrm Ġ= Ġ''. join (list (re versed (m )))ĊĊ ĠĠĠ Ġif Ġm Ġ== Ġrm :ĊĊ ĠĠĠĠĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊ print (count )


Input:
import sys

from operator import itemgetter

from heapq import heapify, heappop, heappush

MAX_INT = int(10e15)

MIN_INT = -MAX_INT

mod = 1000000007

sys.setrecursionlimit(1000000)

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

def SL(): return input().split()

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

def S(): return input()

N, T = IL()

ab = [IL() for i in range(N)]

ab.sort(key=itemgetter(0))

#print(ab)

dp = [[0]*(T+1+3000+1) for _ in range(N+1)]

ans = 0

for i in range(N):

  for j in range(T+1+3000+1):

    time, deli = ab[i]

    if 0 <= j-time < T:

      dp[i + 1][j] = max(dp[i][j], dp[i][j - time] + deli)

    else:

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

    ans = max(ans, dp[i + 1][j])

print(ans)

#print(dp)

import Ġsys ĊĊ from Ġoperator Ġimport Ġitem getter ĊĊ from Ġheapq Ġimport Ġheap ify , Ġhe app op , Ġhe app ush ĊĊ MAX _INT Ġ= Ġint ( 1 0 e 1 5 )ĊĊ MIN _INT Ġ= Ġ- MAX _INT ĊĊ mod Ġ= Ġ 1 0 0 0 0 0 0 0 0 7 ĊĊ sys .set rec ursion limit ( 1 0 0 0 0 0 0 )ĊĊ def ĠIL (): Ġreturn Ġlist (map (int ,input (). split ()))ĊĊ def ĠSL (): Ġreturn Ġinput (). split ()ĊĊ def ĠI (): Ġreturn Ġint (sys .stdin .readline ())ĊĊ def ĠS (): Ġreturn Ġinput ()ĊĊĊĊ N , ĠT Ġ= ĠIL ()ĊĊ ab Ġ= Ġ[ IL () Ġfor Ġi Ġin Ġrange (N )]ĊĊ ab .sort (key =item getter ( 0 ))ĊĊ #print (ab )ĊĊĊĊ dp Ġ= Ġ[[ 0 ]*( T + 1 + 3 0 0 0 + 1 ) Ġfor Ġ_ Ġin Ġrange (N + 1 )]ĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ Ġ Ġfor Ġj Ġin Ġrange (T + 1 + 3 0 0 0 + 1 ):ĊĊ ĠĠĠ Ġtime , Ġdel i Ġ= Ġab [i ]ĊĊ ĠĠĠ Ġif Ġ 0 Ġ<= Ġj -time Ġ< ĠT :ĊĊ ĠĠĠĠĠ Ġdp [i Ġ+ Ġ 1 ][ j ] Ġ= Ġmax (dp [i ][ j ], Ġdp [i ][ j Ġ- Ġtime ] Ġ+ Ġdel i )ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠ Ġdp [i Ġ+ Ġ 1 ][ j ] Ġ= Ġdp [i ][ j ]ĊĊ ĠĠĠ Ġans Ġ= Ġmax (ans , Ġdp [i Ġ+ Ġ 1 ][ j ])ĊĊ print (ans )ĊĊĊĊ #print (dp )Ċ


Input:
import sys

read = sys.stdin.read

readline = sys.stdin.readline

readlines = sys.stdin.readlines

sys.setrecursionlimit(10 ** 9)

INF = 1 << 60

MOD = 1000000007

# Reference: https://www.geeksforgeeks.org/queries-number-distinct-elements-subarray/

# Python3 code to find number of

# distinct numbers in a subarray

MAX = 1000001

# structure to store queries

class Query:

    def __init__(self, l, r, idx):

        self.l = l

        self.r = r

        self.idx = idx

# updating the bit array

def update(idx, val, bit, n):

    while idx <= n:

        bit[idx] += val

        idx += idx & -idx

# querying the bit array

def query(idx, bit, n):

    summ = 0

    while idx:

        summ += bit[idx]

        idx -= idx & -idx

    return summ

def answeringQueries(arr, n, queries, q):

    # initialising bit array

    bit = [0] * (n + 1)

    # holds the rightmost index of

    # any number as numbers of a[i]

    # are less than or equal to 10^6

    last_visit = [-1] * MAX

    # answer for each query

    ans = [0] * q

    query_counter = 0

    for i in range(n):

        # If last visit is not -1 update -1 at the

        # idx equal to last_visit[arr[i]]

        if last_visit[arr[i]] != -1:

            update(last_visit[arr[i]] + 1, -1, bit, n)

        # Setting last_visit[arr[i]] as i and

        # updating the bit array accordingly

        last_visit[arr[i]] = i

        update(i + 1, 1, bit, n)

        # If i is equal to r of any query store answer

        # for that query in ans[]

        while query_counter < q and queries[query_counter].r == i:

            ans[queries[query_counter].idx] = query(queries[query_counter].r + 1, bit, n) - query(

                queries[query_counter].l, bit, n

            )

            query_counter += 1

    # print answer for each query

    for i in range(q):

        print((ans[i]))

# This code is contributed by

# sanjeev2552

def main():

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

    C = list(map(int, readline().split()))

    (*LR,) = list(map(int, read().split()))

    queries = [0] * Q

    for i, (l, r) in enumerate(zip(*[iter(LR)] * 2)):

        queries[i] = Query(l - 1, r - 1, i)

    queries.sort(key=lambda x: x.r)

    answeringQueries(C, N, queries, Q)

    return

if __name__ == '__main__':

    main()

import Ġsys ĊĊĊĊ 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 ĊĊ MOD Ġ= Ġ 1 0 0 0 0 0 0 0 0 7 ĊĊĊĊ # ĠReference : Ġhttps :// www .ge eks forge eks .org / queries -number -dist inct -elements -sub array /ĊĊ # ĠPython 3 Ġcode Ġto Ġfind Ġnumber Ġof ĊĊ # Ġdistinct Ġnumbers Ġin Ġa Ġsub array ĊĊ MAX Ġ= Ġ 1 0 0 0 0 0 1 ĊĊĊĊ # Ġstructure Ġto Ġstore Ġqueries ĊĊ class ĠQuery :ĊĊ ĠĠĠ Ġdef Ġ__ init __( self , Ġl , Ġr , Ġidx ):ĊĊ ĠĠĠĠĠĠĠ Ġself .l Ġ= Ġl ĊĊ ĠĠĠĠĠĠĠ Ġself .r Ġ= Ġr ĊĊ ĠĠĠĠĠĠĠ Ġself .idx Ġ= Ġidx ĊĊĊĊĊĊ # Ġupdating Ġthe Ġbit Ġarray ĊĊ def Ġupdate (idx , Ġval , Ġbit , Ġn ):ĊĊ ĠĠĠ Ġwhile Ġidx Ġ<= Ġn :ĊĊ ĠĠĠĠĠĠĠ Ġbit [idx ] Ġ+= Ġval ĊĊ ĠĠĠĠĠĠĠ Ġidx Ġ+= Ġidx Ġ& Ġ- idx ĊĊĊĊĊĊ # Ġquerying Ġthe Ġbit Ġarray ĊĊ def Ġquery (idx , Ġbit , Ġn ):ĊĊ ĠĠĠ Ġsumm Ġ= Ġ 0 ĊĊ ĠĠĠ Ġwhile Ġidx :ĊĊ ĠĠĠĠĠĠĠ Ġsumm Ġ+= Ġbit [idx ]ĊĊ ĠĠĠĠĠĠĠ Ġidx Ġ-= Ġidx Ġ& Ġ- idx ĊĊ ĠĠĠ Ġreturn Ġsumm ĊĊĊĊĊĊ def Ġanswering Queries (arr , Ġn , Ġqueries , Ġq ): ĊĊĊĊ ĠĠĠ Ġ# Ġinitial ising Ġbit Ġarray ĊĊ ĠĠĠ Ġbit Ġ= Ġ[ 0 ] Ġ* Ġ( n Ġ+ Ġ 1 )ĊĊĊĊ ĠĠĠ Ġ# Ġholds Ġthe Ġright most Ġindex Ġof ĊĊ ĠĠĠ Ġ# Ġany Ġnumber Ġas Ġnumbers Ġof Ġa [i ]ĊĊ ĠĠĠ Ġ# Ġare Ġless Ġthan Ġor Ġequal Ġto Ġ 1 0 ^ 6 ĊĊ ĠĠĠ Ġlast _visit Ġ= Ġ[- 1 ] Ġ* ĠMAX ĊĊĊĊ ĠĠĠ Ġ# Ġanswer Ġfor Ġeach Ġquery ĊĊ ĠĠĠ Ġans Ġ= Ġ[ 0 ] Ġ* Ġq ĊĊĊĊ ĠĠĠ Ġquery _counter Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ): ĊĊĊĊ ĠĠĠĠĠĠĠ Ġ# ĠIf Ġlast Ġvisit Ġis Ġnot Ġ- 1 Ġupdate Ġ- 1 Ġat Ġthe ĊĊ ĠĠĠĠĠĠĠ Ġ# Ġidx Ġequal Ġto Ġlast _visit [arr [i ]]ĊĊ ĠĠĠĠĠĠĠ Ġif Ġlast _visit [arr [i ]] Ġ!= Ġ- 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġupdate (last _visit [arr [i ]] Ġ+ Ġ 1 , Ġ- 1 , Ġbit , Ġn )ĊĊĊĊ ĠĠĠĠĠĠĠ Ġ# ĠSetting Ġlast _visit [arr [i ]] Ġas Ġi Ġand ĊĊ ĠĠĠĠĠĠĠ Ġ# Ġupdating Ġthe Ġbit Ġarray Ġaccordingly ĊĊ ĠĠĠĠĠĠĠ Ġlast _visit [arr [i ]] Ġ= Ġi ĊĊ ĠĠĠĠĠĠĠ Ġupdate (i Ġ+ Ġ 1 , Ġ 1 , Ġbit , Ġn )ĊĊĊĊ ĠĠĠĠĠĠĠ Ġ# ĠIf Ġi Ġis Ġequal Ġto Ġr Ġof Ġany Ġquery Ġstore Ġanswer ĊĊ ĠĠĠĠĠĠĠ Ġ# Ġfor Ġthat Ġquery Ġin Ġans [] ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġquery _counter Ġ< Ġq Ġand Ġqueries [ query _counter ]. r Ġ== Ġi :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans [ queries [ query _counter ]. idx ] Ġ= Ġquery ( queries [ query _counter ]. r Ġ+ Ġ 1 , Ġbit , Ġn ) Ġ- Ġquery (ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġqueries [ query _counter ]. l , Ġbit , Ġn ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġ)ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġquery _counter Ġ+= Ġ 1 ĊĊĊĊ ĠĠĠ Ġ# Ġprint Ġanswer Ġfor Ġeach Ġquery ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (q ):ĊĊ ĠĠĠĠĠĠĠ Ġprint (( ans [i ])) ĊĊĊĊĊĊ # ĠThis Ġcode Ġis Ġcontributed Ġby ĊĊ # Ġsan jee v 2 5 5 2 ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ ĠN , ĠQ Ġ= Ġlist (map (int , Ġreadline (). split ()))ĊĊ ĠĠĠ ĠC Ġ= Ġlist (map (int , Ġreadline (). split ()))ĊĊ ĠĠĠ Ġ(* LR ,) Ġ= Ġlist (map (int , Ġread (). split ())) ĊĊĊĊ ĠĠĠ Ġqueries Ġ= Ġ[ 0 ] Ġ* ĠQ ĊĊ ĠĠĠ Ġfor Ġi , Ġ( l , Ġr ) Ġin Ġenumerate (zip (* [ iter (L R )] Ġ* Ġ 2 )) :ĊĊ ĠĠĠĠĠĠĠ Ġqueries [i ] Ġ= ĠQuery (l Ġ- Ġ 1 , Ġr Ġ- Ġ 1 , Ġi )ĊĊĊĊ ĠĠĠ Ġqueries .sort (key =lambda Ġx : Ġx .r )ĊĊ ĠĠĠ Ġanswering Queries (C , ĠN , Ġqueries , ĠQ )ĊĊĊĊ ĠĠĠ Ġreturn ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()ĊĊĊ


Input:
k = int(input())

num = 0

if not k%2:

    print((-1))

else:

    for i in range(k):

        num = (num*10+7)%k

        if num == 0:

            print((i+1))

            break

    else:

        print((-1))

k Ġ= Ġint (input ())ĊĊ num Ġ= Ġ 0 ĊĊ if Ġnot Ġk % 2 :ĊĊ ĠĠĠ Ġprint ((- 1 ))ĊĊ else :ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (k ):ĊĊ ĠĠĠĠĠĠĠ Ġnum Ġ= Ġ( num * 1 0 + 7 )% k ĊĊ ĠĠĠĠĠĠĠ Ġif Ġnum Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (( i + 1 ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġprint ((- 1 ))


Input:
k = int(input())

count = 1

n = 0

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

    print((-1))

else:

  while 1:

      n = (n * 10 + 7) % k

      if n == 0:

        break

      count += 1

  print(count)

k Ġ= Ġint (input ())ĊĊ count Ġ= Ġ 1 ĊĊ n Ġ= Ġ 0 ĊĊ if Ġk Ġ% Ġ 2 Ġ== Ġ 0 Ġor Ġk Ġ% Ġ 5 Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġprint ((- 1 ))ĊĊ else :ĊĊ Ġ Ġwhile Ġ 1 :ĊĊ ĠĠĠĠĠ Ġn Ġ= Ġ( n Ġ* Ġ 1 0 Ġ+ Ġ 7 ) Ġ% Ġk ĠĠĊĊ ĠĠĠĠĠ Ġif Ġn Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĠĊĊ ĠĠĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊ Ġ Ġprint (count )


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

print((c*10 + b + a))

a , Ġb , Ġc Ġ= Ġsorted (map (int , Ġinput (). split ())) ĊĊĊĊ print (( c * 1 0 Ġ+ Ġb Ġ+ Ġa ))


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

ans = float('inf')

for i in range(200005):

    tmp = i * 2 * c

    tmp += max(0, x-i) * a

    tmp += max(0, y-i) * b

    ans = min(ans, tmp)

print(ans)

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


Input:
N = int(input())

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

def dfs(A_s, index,Bss):

    if index == N:

        tmp = 1

        for b in Bss:

            tmp *= b

        return 1 if tmp % 2 == 0 else 0

    b_mi = Bss.copy()

    b_mi.append(A_s[index] - 1)

    b = Bss.copy()

    b.append(A_s[index])

    b_pl = Bss.copy()

    b_pl.append(A_s[index] + 1)

    return dfs(A_s,index + 1, b_mi) + dfs(A_s,index + 1,b) + dfs(A_s,index + 1,b_pl)

print((dfs(As,0,[])))

N Ġ= Ġint (input ())ĊĊ As Ġ= Ġlist (map (int ,input (). split ())) ĊĊĊĊĊĊ def Ġdfs (A _s , Ġindex ,B ss ):ĊĊ ĠĠĠ Ġif Ġindex Ġ== ĠN :ĊĊ ĠĠĠĠĠĠĠ Ġtmp Ġ= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġb Ġin ĠB ss :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġtmp Ġ*= Ġb ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ 1 Ġif Ġtmp Ġ% Ġ 2 Ġ== Ġ 0 Ġelse Ġ 0 ĊĊ ĠĠĠ Ġb _mi Ġ= ĠB ss .copy ()ĊĊ ĠĠĠ Ġb _mi .append (A _s [index ] Ġ- Ġ 1 )ĊĊĊĊ ĠĠĠ Ġb Ġ= ĠB ss .copy ()ĊĊ ĠĠĠ Ġb .append (A _s [index ])ĊĊ ĊĊ ĠĠĠ Ġb _pl Ġ= ĠB ss .copy ()ĊĊ ĠĠĠ Ġb _pl .append (A _s [index ] Ġ+ Ġ 1 )ĊĊ ĠĠĠ Ġreturn Ġdfs (A _s ,index Ġ+ Ġ 1 , Ġb _mi ) Ġ+ Ġdfs (A _s ,index Ġ+ Ġ 1 ,b ) Ġ+ Ġdfs (A _s ,index Ġ+ Ġ 1 ,b _pl )ĊĊĊĊĊĊ print (( dfs ( As , 0 , [] )))Ċ


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:
from sys import stdin

from math import factorial

def combinations_count(n, r):

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

def combinations_with_replacement_count(n, r):

    return combinations_count(n + r - 1, r)

def main():

    _in = [_.rstrip() for _ in stdin.readlines()]

    S = int(_in[0])  # type:int

    # vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv

    min_ = 1

    max_ = S // 3

    ans = 0

    for i in range(min_, max_ + 1):

        mod = S - i * 3

        ans += combinations_with_replacement_count(mod + 1, i - 1) % (10**9 + 7)

    ans %= (10**9 + 7)

    # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

    print(ans)

if __name__ == "__main__":

    main()

from Ġsys Ġimport Ġstdin ĊĊ from Ġmath Ġimport Ġfactorial ĊĊĊĊĊĊ def Ġcombinations _count (n , Ġr ):ĊĊ ĠĠĠ Ġreturn Ġfactorial (n ) Ġ// Ġ( factor ial (n Ġ- Ġr ) Ġ* Ġfactorial (r )) ĊĊĊĊĊĊ def Ġcombinations _with _re placement _count (n , Ġr ):ĊĊ ĠĠĠ Ġreturn Ġcombinations _count (n Ġ+ Ġr Ġ- Ġ 1 , Ġr )ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġ_ in Ġ= Ġ[ _. rstrip () Ġfor Ġ_ Ġin Ġstdin .readlines ()]ĊĊ ĠĠĠ ĠS Ġ= Ġint (_ in [ 0 ]) Ġ Ġ# Ġtype :int ĊĊ ĠĠĠ Ġ# Ġv vv vv vv vv vv vv vv vv vv vv vv vv vv vv vv vv vv vv vv vv vv vv vv vv vv ĊĊ ĠĠĠ Ġmin _ Ġ= Ġ 1 ĊĊ ĠĠĠ Ġmax _ Ġ= ĠS Ġ// Ġ 3 ĊĊ ĠĠĠ Ġans Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (min _, Ġmax _ Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġmod Ġ= ĠS Ġ- Ġi Ġ* Ġ 3 ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġcombinations _with _re placement _count (mod Ġ+ Ġ 1 , Ġi Ġ- Ġ 1 ) Ġ% Ġ( 1 0 ** 9 Ġ+ Ġ 7 )ĊĊ ĠĠĠ Ġans Ġ%= Ġ( 1 0 ** 9 Ġ+ Ġ 7 )ĊĊ ĠĠĠ Ġ# Ġ^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^ ĊĊ ĠĠĠ Ġprint (ans )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
n = int(input())

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

tmp = [[e, n - i] for i, e in enumerate(a)]

tmp.sort(reverse=True)

aa = [[e, n - i] for e, i in tmp] + [[0, -1]]

v_prev, i_prev = aa[0]

i = 0

ans = [0] * n

sm = 0

while i < n:

    while aa[i][1] >= i_prev:

        sm += aa[i][0]

        i += 1

    ans[i_prev] += sm - aa[i][0] * i

    sm = aa[i][0] * i

    v_prev, i_prev = aa[i]

print(*ans, sep="\n")

n Ġ= Ġint (input ())ĊĊ a Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ tmp Ġ= Ġ[[ e , Ġn Ġ- Ġi ] Ġfor Ġi , Ġe Ġin Ġenumerate (a )]ĊĊ tmp .sort (reverse =True )ĊĊĊĊ aa Ġ= Ġ[[ e , Ġn Ġ- Ġi ] Ġfor Ġe , Ġi Ġin Ġtmp ] Ġ+ Ġ[[ 0 , Ġ- 1 ]] ĊĊĊĊ v _prev , Ġi _prev Ġ= Ġaa [ 0 ]ĊĊ i Ġ= Ġ 0 ĊĊ ans Ġ= Ġ[ 0 ] Ġ* Ġn ĊĊ sm Ġ= Ġ 0 ĊĊ while Ġi Ġ< Ġn :ĊĊ ĠĠĠ Ġwhile Ġaa [i ][ 1 ] Ġ>= Ġi _prev :ĊĊ ĠĠĠĠĠĠĠ Ġsm Ġ+= Ġaa [i ][ 0 ]ĊĊ ĠĠĠĠĠĠĠ Ġi Ġ+= Ġ 1 ĊĊĊĊ ĠĠĠ Ġans [i _prev ] Ġ+= Ġsm Ġ- Ġaa [i ][ 0 ] Ġ* Ġi ĊĊ ĠĠĠ Ġsm Ġ= Ġaa [i ][ 0 ] Ġ* Ġi ĊĊ ĠĠĠ Ġv _prev , Ġi _prev Ġ= Ġaa [i ]ĊĊĊĊ print (* ans , Ġsep ="\ n ")Ċ


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

A_ = [int(input()) for _ in range(M)]

A = [0] * (N+3)

for a in A_:

    A[a] = 1

dp = [0] * (N+3)

dp[0] = 1

mod = 10**9+7

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

    if A[i-1] == 0:

        dp[i] += dp[i-1]

    if A[i-2] == 0:

        dp[i] += dp[i-2]

    dp[i] %= mod

print((dp[N]))

N , ĠM Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ A _ Ġ= Ġ[ int (input ()) Ġfor Ġ_ Ġin Ġrange (M )]ĊĊ A Ġ= Ġ[ 0 ] Ġ* Ġ( N + 3 )ĊĊ for Ġa Ġin ĠA _ :ĊĊ ĠĠĠ ĠA [a ] Ġ= Ġ 1 ĊĊ dp Ġ= Ġ[ 0 ] Ġ* Ġ( N + 3 )ĊĊ dp [ 0 ] Ġ= Ġ 1 ĊĊĊĊ mod Ġ= Ġ 1 0 ** 9 + 7 ĊĊĊĊ for Ġi Ġin Ġrange ( 1 , ĠN + 1 ):ĊĊ ĠĠĠ Ġif ĠA [i - 1 ] Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġdp [i ] Ġ+= Ġdp [i - 1 ]ĊĊ ĠĠĠ Ġif ĠA [i - 2 ] Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġdp [i ] Ġ+= Ġdp [i - 2 ]ĊĊ ĠĠĠ Ġdp [i ] Ġ%= Ġmod ĊĊ print (( dp [N ]))


Input:
n=int(input())

D={}

DD={}

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

   s=(str(i)[0],str(i)[-1])

   t=(str(i)[-1],str(i)[0])

   if s not in D:

      D[s]=1

   else:

      D[s]+=1

   if t not in DD:

      DD[t]=1

   else:

      DD[t]+=1

ans=0

for i in D:

   if i in DD:

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

print(ans)

n =int (input ())ĊĊ D ={ }ĊĊ DD ={ }ĊĊ for Ġi Ġin Ġrange ( 1 ,n + 1 ):ĊĊ ĠĠ Ġs =( str (i )[ 0 ], str (i )[- 1 ])ĊĊ ĠĠ Ġt =( str (i )[- 1 ], str (i )[ 0 ])ĊĊ ĠĠ Ġif Ġs Ġnot Ġin ĠD :ĊĊ ĠĠĠĠĠ ĠD [s ]= 1 ĊĊ ĠĠ Ġelse :ĊĊ ĠĠĠĠĠ ĠD [s ]+= 1 ĊĊ ĠĠ Ġif Ġt Ġnot Ġin ĠDD :ĊĊ ĠĠĠĠĠ ĠDD [t ]= 1 ĊĊ ĠĠ Ġelse :ĊĊ ĠĠĠĠĠ ĠDD [t ]+= 1 ĊĊ ans = 0 ĊĊ for Ġi Ġin ĠD :ĊĊ ĠĠ Ġif Ġi Ġin ĠDD :ĊĊ ĠĠĠĠĠ Ġans += D [i ]* DD [i ]ĊĊ print (ans )ĊĊ ĠĠĠĠĠĠ


Input:
import math

N = int(input())

ans = 0

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

print(ans)

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


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

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

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

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

asort,bsort,csort = sorted(A,reverse=True),sorted(B,reverse=True),sorted(C,reverse=True)

print((asort[0] + bsort[0] + csort[0]))

already = [[0,0,0]]

x,y,z = 0,0,0

place_sum = []

check = []

for k in range(K - 1):

    if [x + 1,y,z] not in already and x + 1 < X:

        already.append([x + 1,y,z])

        place_sum.append([x + 1,y,z])

        check.append(asort[x + 1] + bsort[y] + csort[z])

    if [x,y + 1,z] not in already and y + 1 < Y:

        already.append([x,y + 1,z])

        place_sum.append([x,y + 1,z])

        check.append(asort[x] + bsort[y + 1] + csort[z])

    if [x,y,z + 1] not in already and z + 1 < Z:

        already.append([x,y,z + 1])

        place_sum.append([x,y,z + 1])

        check.append(asort[x] + bsort[y] + csort[z + 1])

    print((max(check)))

    x,y,z = place_sum[check.index(max(check))][0],place_sum[check.index(max(check))][1],place_sum[check.index(max(check))][2]

    place_sum.pop(check.index(max(check)))

    check.remove(max(check))

X ,Y ,Z ,K Ġ= Ġlist (map (int ,input (). split ()))ĊĊ A Ġ= Ġlist (map (int ,input (). split ()))ĊĊ B Ġ= Ġlist (map (int ,input (). split ()))ĊĊ C Ġ= Ġlist (map (int ,input (). split ()))ĊĊ as ort , bs ort , cs ort Ġ= Ġsorted (A , reverse =True ), sorted (B , reverse =True ), sorted (C , reverse =True )ĊĊ print (( as ort [ 0 ] Ġ+ Ġb sort [ 0 ] Ġ+ Ġc sort [ 0 ]))ĊĊ already Ġ= Ġ[[ 0 , 0 , 0 ]]ĊĊ x ,y ,z Ġ= Ġ 0 , 0 , 0 ĊĊ place _sum Ġ= Ġ[]ĊĊ check Ġ= Ġ[]ĊĊ for Ġk Ġin Ġrange (K Ġ- Ġ 1 ):ĊĊ ĠĠĠ Ġif Ġ[ x Ġ+ Ġ 1 ,y ,z ] Ġnot Ġin Ġalready Ġand Ġx Ġ+ Ġ 1 Ġ< ĠX :ĊĊ ĠĠĠĠĠĠĠ Ġalready .append ([ x Ġ+ Ġ 1 ,y ,z ])ĊĊ ĠĠĠĠĠĠĠ Ġplace _sum .append ([ x Ġ+ Ġ 1 ,y ,z ])ĊĊ ĠĠĠĠĠĠĠ Ġcheck .append (as ort [x Ġ+ Ġ 1 ] Ġ+ Ġb sort [y ] Ġ+ Ġc sort [z ])ĊĊ ĠĠĠ Ġif Ġ[ x ,y Ġ+ Ġ 1 ,z ] Ġnot Ġin Ġalready Ġand Ġy Ġ+ Ġ 1 Ġ< ĠY :ĊĊ ĠĠĠĠĠĠĠ Ġalready .append ([ x ,y Ġ+ Ġ 1 ,z ])ĊĊ ĠĠĠĠĠĠĠ Ġplace _sum .append ([ x ,y Ġ+ Ġ 1 ,z ])ĊĊ ĠĠĠĠĠĠĠ Ġcheck .append (as ort [x ] Ġ+ Ġb sort [y Ġ+ Ġ 1 ] Ġ+ Ġc sort [z ])ĊĊ ĠĠĠ Ġif Ġ[ x ,y ,z Ġ+ Ġ 1 ] Ġnot Ġin Ġalready Ġand Ġz Ġ+ Ġ 1 Ġ< ĠZ :ĊĊ ĠĠĠĠĠĠĠ Ġalready .append ([ x ,y ,z Ġ+ Ġ 1 ])ĊĊ ĠĠĠĠĠĠĠ Ġplace _sum .append ([ x ,y ,z Ġ+ Ġ 1 ])ĊĊ ĠĠĠĠĠĠĠ Ġcheck .append (as ort [x ] Ġ+ Ġb sort [y ] Ġ+ Ġc sort [z Ġ+ Ġ 1 ])ĊĊ ĠĠĠ Ġprint (( max (check )))ĊĊ ĠĠĠ Ġx ,y ,z Ġ= Ġplace _sum [ check .index (max (check )) ][ 0 ], place _sum [ check .index (max (check )) ][ 1 ], place _sum [ check .index (max (check )) ][ 2 ]ĊĊ ĠĠĠ Ġplace _sum .pop (check .index (max (check )))ĊĊ ĠĠĠ Ġcheck .remove (max (check ))


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

ans=a*x+b*y

n=max(x,y)

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

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

print(ans)

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


Input:
answer = 0

N = int(input())

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

for i in range(N) :

    while A[i] % 2 == 0 :

        A[i] = A[i] / 2

        answer += 1

print(answer)

answer Ġ= Ġ 0 ĊĊ N Ġ= Ġint (input ())ĊĊ A Ġ= Ġlist (map (int ,input (). split ()))ĊĊ for Ġi Ġin Ġrange (N ) Ġ:ĊĊ ĠĠĠ Ġwhile ĠA [i ] Ġ% Ġ 2 Ġ== Ġ 0 Ġ:ĊĊ ĠĠĠĠĠĠĠ ĠA [i ] Ġ= ĠA [i ] Ġ/ Ġ 2 ĊĊ ĠĠĠĠĠĠĠ Ġanswer Ġ+= Ġ 1 ĊĊ print (answer )ĊĊĊ


Input:
import sys

def main():

    input = sys.stdin.readline

    N = int(input())

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

    ans = 0

    for C in range(1, N//2):

        n = N // C

        point = 0

        used = set([0])

        for k in range(1, n):

            A = N - 1 - k*C

            if A in used or k*C in used or A == k*C:

                break

            used.add(A)

            used.add(k*C)

            point += S[A] + S[k*C]

            ans = max(ans, point)

    return ans

if __name__ == '__main__':

    print((main()))

import Ġsys ĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġinput Ġ= Ġsys .stdin .readline ĊĊ ĠĠĠ ĠN Ġ= Ġint (input ())ĊĊ ĠĠĠ ĠS Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ ĠĠĠ Ġans Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor ĠC Ġin Ġrange ( 1 , ĠN // 2 ):ĊĊ ĠĠĠĠĠĠĠ Ġn Ġ= ĠN Ġ// ĠC ĊĊ ĠĠĠĠĠĠĠ Ġpoint Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġused Ġ= Ġset ([ 0 ])ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġk Ġin Ġrange ( 1 , Ġn ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠA Ġ= ĠN Ġ- Ġ 1 Ġ- Ġk *C ĊĊĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif ĠA Ġin Ġused Ġor Ġk *C Ġin Ġused Ġor ĠA Ġ== Ġk *C :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġused .add (A )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġused .add (k *C )ĊĊĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġpoint Ġ+= ĠS [A ] Ġ+ ĠS [k *C ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ= Ġmax (ans , Ġpoint )ĊĊĊĊ ĠĠĠ Ġreturn Ġans ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġprint (( main ()))Ċ


Input:
import sys

input = sys.stdin.readline

def I(): return int(input())

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

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

def main():

    mod=10**9+7

    N,M=MI()

    A=LI()

    CB=[[0,0]for _ in range(M)]

    A.sort()

    for i in range(M):

        CB[i][1],CB[i][0]=MI()

    CB.sort(reverse=True)

    now=0

    for i in range(N):

        if CB[now][1]<=0:

            now+=1

        if now>=M:

            break

        ch=CB[now][0]

        if A[i]<ch:

            A[i]=ch

            CB[now][1]-=1

        else:

            break

    print((sum(A)))

main()

import Ġsys ĊĊ input Ġ= Ġsys .stdin .readline ĊĊĊĊ def ĠI (): Ġreturn Ġint (input ())ĊĊ def ĠMI (): Ġreturn Ġlist (map (int , Ġinput (). split ()))ĊĊ def ĠLI (): Ġreturn Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġmod = 1 0 ** 9 + 7 ĊĊ ĠĠĠ ĠN ,M = MI ()ĊĊ ĠĠĠ ĠA = LI ()ĊĊ ĠĠĠ ĠCB =[[ 0 , 0 ] for Ġ_ Ġin Ġrange (M )]ĊĊ ĠĠĠ ĠA .sort ()ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (M ):ĊĊ ĠĠĠĠĠĠĠ ĠCB [i ][ 1 ], CB [i ][ 0 ]= MI ()ĊĊ ĠĠĠĠĠĠĠĠĊĊ ĠĠĠ ĠCB .sort (reverse =True )ĊĊ ĠĠĠ Ġnow = 0 ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠĠĠĠĠ Ġif ĠCB [now ][ 1 ]<= 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġnow += 1 ĊĊ ĠĠĠĠĠĠĠĠĊĊ ĠĠĠĠĠĠĠ Ġif Ġnow >= M :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĠĠĠĠĊĊ ĠĠĠĠĠĠĠĠĊĊ ĠĠĠĠĠĠĠ Ġch = CB [now ][ 0 ]ĊĊ ĠĠĠĠĠĠĠ Ġif ĠA [i ]< ch :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠA [i ]= ch ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠCB [now ][ 1 ]- = 1 ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĊĊ ĠĠĠ Ġprint (( sum (A )))ĊĊ ĠĠĠĠ ĊĊĊĊ main ()Ċ


Input:
from math import factorial

n = int(input())

f = factorial(n)

mod = 10 ** 9 + 7

def primes(n):

    is_prime = [True] * (n + 1)

    is_prime[0] = False

    is_prime[1] = False

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

        if not is_prime[i]:

            continue

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

            is_prime[j] = False

    return [i for i in range(n + 1) if is_prime[i]]

ans = 1

for p in primes(n):

    temp = 1

    while f % p == 0:

        temp += 1

        f //= p

    ans = (ans * temp) % mod

print(ans)

from Ġmath Ġimport Ġfactorial ĊĊĊĊ n Ġ= Ġint (input ())ĊĊ f Ġ= Ġfactorial (n )ĊĊĊĊ mod Ġ= Ġ 1 0 Ġ** Ġ 9 Ġ+ Ġ 7 ĊĊĊĊ def Ġprimes (n ):ĊĊ ĠĠĠ Ġis _prime Ġ= Ġ[ True ] Ġ* Ġ( n Ġ+ Ġ 1 )ĊĊ ĠĠĠ Ġis _prime [ 0 ] Ġ= ĠFalse ĊĊ ĠĠĠ Ġis _prime [ 1 ] Ġ= ĠFalse ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 2 , Ġint (n Ġ** Ġ 0 . 5 ) Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġnot Ġis _prime [i ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange (i Ġ* Ġ 2 , Ġn Ġ+ Ġ 1 , Ġi ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġis _prime [j ] Ġ= ĠFalse ĊĊ ĠĠĠ Ġreturn Ġ[ i Ġfor Ġi Ġin Ġrange (n Ġ+ Ġ 1 ) Ġif Ġis _prime [i ]] ĊĊĊĊ ans Ġ= Ġ 1 ĊĊ for Ġp Ġin Ġprimes (n ):ĊĊ ĠĠĠ Ġtemp Ġ= Ġ 1 ĊĊ ĠĠĠ Ġwhile Ġf Ġ% Ġp Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġtemp Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġf Ġ//= Ġp ĊĊ ĠĠĠ Ġans Ġ= Ġ( ans Ġ* Ġtemp ) Ġ% Ġmod ĊĊ print (ans )Ċ


Input:
from collections import defaultdict

from bisect import bisect_left

s = input()

n = len(s)

s = s + s

t = input()

if set(t) - set(s):

	print((-1))

	exit()

d = defaultdict(list)

for i in range(2 * n):

	d[s[i]] += [i]

cur = tot = 0

for c in t:

	x = d[c][bisect_left(d[c], cur)]

	if x < n:

		cur = x + 1

	else:

		cur = x - n + 1

		tot += n

tot += cur

print(tot)

from Ġcollections Ġimport Ġdefaultdict ĊĊ from Ġbis ect Ġimport Ġbis ect _left ĊĊĊĊ s Ġ= Ġinput ()ĊĊ n Ġ= Ġlen (s )ĊĊ s Ġ= Ġs Ġ+ Ġs ĊĊ t Ġ= Ġinput ()ĊĊ if Ġset (t ) Ġ- Ġset (s ):ĊĊ ĉprint ((- 1 ))ĊĊ ĉexit ()ĊĊ d Ġ= Ġdefaultdict (list )ĊĊ for Ġi Ġin Ġrange ( 2 Ġ* Ġn ):ĊĊ ĉd [s [i ]] Ġ+= Ġ[ i ]ĊĊ cur Ġ= Ġtot Ġ= Ġ 0 ĊĊ for Ġc Ġin Ġt :ĊĊ ĉx Ġ= Ġd [c ][ bis ect _left (d [c ], Ġcur )]ĊĊ ĉif Ġx Ġ< Ġn :ĊĊ ĉ ĉcur Ġ= Ġx Ġ+ Ġ 1 ĊĊ ĉelse :ĊĊ ĉ ĉcur Ġ= Ġx Ġ- Ġn Ġ+ Ġ 1 ĊĊ ĉ ĉt ot Ġ+= Ġn ĊĊ tot Ġ+= Ġcur ĊĊ print (t ot )Ċ


Input:
import sys

stdin = sys.stdin

sys.setrecursionlimit(10 ** 7)

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

def li_(): return [int(x) - 1 for x in stdin.readline().split()]

def lf(): return list(map(float, stdin.readline().split()))

def ls(): return stdin.readline().split()

def ns(): return stdin.readline().rstrip()

def lc(): return list(ns())

def ni(): return int(stdin.readline())

def nf(): return float(stdin.readline())

n = ni()

ab = [list(li()) for _ in range(n)]

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

cur = 0

ans = True

for ai, bi in ab:

    cur += ai

    if cur > bi:

        ans = False

print(("Yes" if ans else "No"))

import Ġsys ĊĊ stdin Ġ= Ġsys .stdin ĊĊĊĊ sys .set rec ursion limit ( 1 0 Ġ** Ġ 7 )ĊĊĊĊ def Ġli (): Ġreturn Ġlist (map (int , Ġstdin .readline (). split ()))ĊĊ def Ġli _ (): Ġreturn Ġ[ int (x ) Ġ- Ġ 1 Ġfor Ġx Ġin Ġstdin .readline (). split ()]ĊĊ def Ġlf (): Ġreturn Ġlist (map (float , Ġstdin .readline (). split ()))ĊĊ def Ġls (): Ġreturn Ġstdin .readline (). split ()ĊĊ def Ġns (): Ġreturn Ġstdin .readline (). rstrip ()ĊĊ def Ġlc (): Ġreturn Ġlist (ns ())ĊĊ def Ġni (): Ġreturn Ġint (stdin .readline ())ĊĊ def Ġnf (): Ġreturn Ġfloat (stdin .readline ())ĊĊ ĊĊ n Ġ= Ġni ()ĊĊ ab Ġ= Ġ[ list (li ()) Ġfor Ġ_ Ġin Ġrange (n )] ĊĊĊĊ ab .sort (key =lambda Ġx : Ġx [ 1 ])ĊĊ ĊĊ cur Ġ= Ġ 0 ĊĊĊĊ ans Ġ= ĠTrue ĊĊĊĊ for Ġai , Ġbi Ġin Ġab :ĊĊ ĠĠĠ Ġcur Ġ+= Ġai ĊĊ ĠĠĠ Ġif Ġcur Ġ> Ġbi :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ= ĠFalse ĊĊĊĊ print ((" Yes " Ġif Ġans Ġelse Ġ" No "))


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

ans = 0

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

    if str(i)[0]+str(i)[1] == str(i)[-1]+str(i)[-2]: ans += 1

print(ans)

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


Input:
ans=[]

for i in range (0,10):

    ans.append(int(input()))

ans.sort(reverse=True)

for i in range (0,3):

    print((ans[i]))

ans =[] ĊĊ for Ġi Ġin Ġrange Ġ( 0 , 1 0 ):ĊĊ ĠĠĠ Ġans .append (int (input ()))ĊĊ ans .sort (reverse =True )ĊĊ for Ġi Ġin Ġrange Ġ( 0 , 3 ):ĊĊ ĠĠĠ Ġprint (( ans [i ]))


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

import sys

def main():

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

    dp = [0]*(S+1)

    dp[0] = 1

    mod = 10**9 + 7

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

        cnt = 0

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

            cnt += dp[i-j]

            cnt %= mod

        dp[i] = cnt

    print((dp[-1]))

if __name__ == "__main__":

    main()

# Ġ-*- Ġcoding : Ġutf - 8 Ġ-*-ĊĊ import Ġsys ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ ĠS Ġ= Ġint ( Ġsys .stdin .readline () Ġ)ĊĊ ĊĊ ĠĠĠ Ġdp Ġ= Ġ[ 0 ]*( S + 1 )ĊĊ ĠĠĠ Ġdp [ 0 ] Ġ= Ġ 1 ĊĊ ĠĠĠ Ġmod Ġ= Ġ 1 0 ** 9 Ġ+ Ġ 7 ĊĊĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 3 , ĠS + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ= Ġ 0 ĊĊĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange ( 3 , Ġi + 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġdp [i -j ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ%= Ġmod ĊĊ ĠĠĠĠĠĠĠĠĊĊ ĠĠĠĠĠĠĠ Ġdp [i ] Ġ= Ġcnt ĊĊĊĊĊĊ ĠĠĠ Ġprint (( dp [- 1 ])) ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
def solve():

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

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

  if K>=N:

    return 0

  H.sort()

  ans = sum(H[:N-K])

  return ans

print((solve()))

def Ġsolve ():ĊĊ Ġ ĠN , ĠK Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ Ġ ĠH Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ Ġ Ġif ĠK >= N :ĊĊ ĠĠĠ Ġreturn Ġ 0 ĊĊ Ġ ĠH .sort ()ĊĊ Ġ Ġans Ġ= Ġsum (H [: N -K ])ĊĊ Ġ Ġreturn Ġans ĊĊ print (( solve ()))


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

ans = 0

for x in range(k+1):

  for y in range(k+1):

    if 0<=s-x-y<=k:

      ans += 1

print(ans)

k , Ġs Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ for Ġx Ġin Ġrange (k + 1 ):ĊĊ Ġ Ġfor Ġy Ġin Ġrange (k + 1 ):ĊĊ ĠĠĠ Ġif Ġ 0 <= s -x -y <= k :ĊĊ ĠĠĠĠĠ Ġans Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĊĊ print (ans )


Input:
import sys

N = int(input())

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

l = 1

p = a[0] - 1

if a[0] == 2:

    print(l)

    sys.exit()

while l < int(1e6):

    l += 1

    if a[p] == 2:

        print(l)

        break

    else:

        p = a[p] - 1

else:

    print((-1))

import Ġsys ĊĊĊĊ N Ġ= Ġint (input ())ĊĊ a Ġ= Ġ[ int (input ()) Ġfor Ġ_ Ġin Ġrange (N )] ĊĊĊĊ l Ġ= Ġ 1 ĊĊ p Ġ= Ġa [ 0 ] Ġ- Ġ 1 ĊĊĊĊ if Ġa [ 0 ] Ġ== Ġ 2 :ĊĊ ĠĠĠ Ġprint (l )ĊĊ ĠĠĠ Ġsys .exit ()ĊĊĊĊ while Ġl Ġ< Ġint ( 1 e 6 ):ĊĊ ĠĠĠ Ġl Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġif Ġa [p ] Ġ== Ġ 2 :ĊĊ ĠĠĠĠĠĠĠ Ġprint (l )ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġp Ġ= Ġa [p ] Ġ- Ġ 1 ĊĊ else :ĊĊ ĠĠĠ Ġprint ((- 1 ))


Input:
import math

def main():

    N = int(input())

    power = math.factorial(N)

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

if __name__ == "__main__":

    main()

import Ġmath ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ ĠN Ġ= Ġint (input ())ĊĊ ĠĠĠ Ġpower Ġ= Ġmath .factor ial (N )ĊĊ ĠĠĠ Ġprint (( power Ġ% Ġ( 1 0 Ġ** Ġ 9 Ġ+ Ġ 7 )))ĊĊ ĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
def post_from_pre_in(preorder_elements, inorder_elements):

    if preorder_elements:

        global cnt

        root = preorder_elements[0]

        root_index = inorder_elements.index(root)

        preorder_left = preorder_elements[1:root_index+1]

        inorder_left = inorder_elements[:root_index]

        preorder_right = preorder_elements[root_index+1:]

        inorder_right = inorder_elements[root_index+1:]

        post_from_pre_in(preorder_left, inorder_left)

        post_from_pre_in(preorder_right, inorder_right)

        if cnt:

            print(root, end = ' ')

            cnt -= 1

        else:

            print(root)

cnt = int(input()) - 1

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

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

post_from_pre_in(a, b)

def Ġpost _from _pre _in (pre order _elements , Ġinorder _elements ):ĊĊ ĠĠĠ Ġif Ġpreorder _elements :ĊĊ ĠĠĠĠĠĠĠ Ġglobal Ġcnt ĊĊ ĠĠĠĠĠĠĠ Ġroot Ġ= Ġpreorder _elements [ 0 ]ĊĊ ĠĠĠĠĠĠĠ Ġroot _index Ġ= Ġinorder _elements .index (root )ĊĊ ĠĠĠĠĠĠĠ Ġpreorder _left Ġ= Ġpreorder _elements [ 1 : root _index + 1 ]ĊĊ ĠĠĠĠĠĠĠ Ġinorder _left Ġ= Ġinorder _elements [: root _index ]ĊĊ ĠĠĠĠĠĠĠ Ġpreorder _right Ġ= Ġpreorder _elements [root _index + 1 :]ĊĊ ĠĠĠĠĠĠĠ Ġinorder _right Ġ= Ġinorder _elements [root _index + 1 :]ĊĊ ĠĠĠĠĠĠĠ Ġpost _from _pre _in (pre order _left , Ġinorder _left )ĊĊ ĠĠĠĠĠĠĠ Ġpost _from _pre _in (pre order _right , Ġinorder _right )ĊĊ ĠĠĠĠĠĠĠ Ġif Ġcnt :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (root , Ġend Ġ= Ġ' Ġ')ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ-= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (root )ĊĊĊĊĊĊ cnt Ġ= Ġint (input ()) Ġ- Ġ 1 ĊĊĊĊ a Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ b Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ post _from _pre _in (a , Ġb )Ċ


Input:
def main():

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

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

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

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

	d = [0]*x*y

	for i in range(x):

		for j in range(y):

			d[i*y+j] = a[i]+b[j]

	d.sort(reverse=True)

	c.sort(reverse=True)

	c_len = min(k, z)

	d_len = min(k, x*y)

	e = [0]*d_len*c_len

	for i in range(d_len):

		for j in range(c_len):

			e[i*c_len+j] = d[i] + c[j]

	e.sort(reverse=True)

	for i in range(k):

		print((e[i]))

if __name__ == '__main__':

    main()

def Ġmain ():ĊĊ ĉx , Ġy , Ġz , Ġk Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĉa Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĉb Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĉc Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĉd Ġ= Ġ[ 0 ]* x *y ĊĊ ĉfor Ġi Ġin Ġrange (x ):ĊĊ ĉ ĉfor Ġj Ġin Ġrange (y ):ĊĊ ĉĉ ĉd [i *y +j ] Ġ= Ġa [i ]+ b [j ]ĊĊ ĉd .sort (reverse =True )ĊĊ ĉc .sort (reverse =True )ĊĊĊĊ ĉc _len Ġ= Ġmin (k , Ġz )ĊĊ ĉd _len Ġ= Ġmin (k , Ġx *y )ĊĊ ĉe Ġ= Ġ[ 0 ]* d _len *c _len ĊĊ ĉfor Ġi Ġin Ġrange (d _len ):ĊĊ ĉ ĉfor Ġj Ġin Ġrange (c _len ):ĊĊ ĉĉ ĉe [i *c _len +j ] Ġ= Ġd [i ] Ġ+ Ġc [j ]ĊĊ ĉe .sort (reverse =True )ĊĊ ĉfor Ġi Ġin Ġrange (k ):ĊĊ ĉ ĉprint (( e [i ])) ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()


Input:
from math import sqrt

from bisect import bisect_left

def circle_center(x1, y1, x2, y2):

    xd = x2 - x1; yd = y2 - y1

    d = xd**2 + yd**2

    k = sqrt((4.0 - d) / d) / 2.0

    xc = (x1 + x2) / 2.0

    yc = (y1 + y2) / 2.0

    return [[xc - k*yd, yc + k*xd], [xc + k*yd, yc - k*xd]]

while 1:

    n = int(input())

    if n==0: break

    p = [list(map(float, input().split())) for i in range(n)]

    p.sort()

    prev = 0

    ans = 1

    for i in range(n):

        bx, by = p[i]

        while bx - p[prev][0] >= 2.0: prev += 1

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

            cx, cy = p[j]

            if cx - bx >= 2.0: break

            if (bx - cx)**2 + (by - cy)**2 <= 4.0:

                for ex, ey in circle_center(bx, by, cx, cy):

                    count = 2

                    for k in range(prev, n):

                        if k==i or k==j: continue

                        dx, dy = p[k]

                        if dx - bx >= 2.0: break

                        if (ex - dx)**2 + (ey - dy)**2 <= 1.0:

                            count += 1

                    ans = max(ans, count)

    print(ans)

from Ġmath Ġimport Ġsqrt ĊĊ from Ġbis ect Ġimport Ġbis ect _left ĊĊ def Ġcircle _center (x 1 , Ġy 1 , Ġx 2 , Ġy 2 ):ĊĊ ĠĠĠ Ġxd Ġ= Ġx 2 Ġ- Ġx 1 ; Ġy d Ġ= Ġy 2 Ġ- Ġy 1 ĊĊ ĠĠĠ Ġd Ġ= Ġxd ** 2 Ġ+ Ġy d ** 2 ĊĊ ĠĠĠ Ġk Ġ= Ġsqrt (( 4 . 0 Ġ- Ġd ) Ġ/ Ġd ) Ġ/ Ġ 2 . 0 ĊĊ ĠĠĠ Ġxc Ġ= Ġ( x 1 Ġ+ Ġx 2 ) Ġ/ Ġ 2 . 0 ĊĊ ĠĠĠ Ġyc Ġ= Ġ( y 1 Ġ+ Ġy 2 ) Ġ/ Ġ 2 . 0 ĊĊ ĠĠĠ Ġreturn Ġ[[ xc Ġ- Ġk *y d , Ġyc Ġ+ Ġk * xd ], Ġ[ xc Ġ+ Ġk *y d , Ġyc Ġ- Ġk * xd ]]ĊĊ while Ġ 1 :ĊĊ ĠĠĠ Ġn Ġ= Ġint (input ())ĊĊ ĠĠĠ Ġif Ġn == 0 : Ġbreak ĊĊ ĠĠĠ Ġp Ġ= Ġ[ list (map (float , Ġinput (). split ())) Ġfor Ġi Ġin Ġrange (n )]ĊĊ ĠĠĠ Ġp .sort ()ĊĊ ĠĠĠ Ġprev Ġ= Ġ 0 ĊĊ ĠĠĠ Ġans Ġ= Ġ 1 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠ Ġbx , Ġby Ġ= Ġp [i ]ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġbx Ġ- Ġp [ prev ][ 0 ] Ġ>= Ġ 2 . 0 : Ġprev Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange (i + 1 , Ġn ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcx , Ġcy Ġ= Ġp [j ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġcx Ġ- Ġbx Ġ>= Ġ 2 . 0 : Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġ( bx Ġ- Ġcx )** 2 Ġ+ Ġ( by Ġ- Ġcy )** 2 Ġ<= Ġ 4 . 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġex , Ġey Ġin Ġcircle _center (b x , Ġby , Ġcx , Ġcy ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġcount Ġ= Ġ 2 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġk Ġin Ġrange (prev , Ġn ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġk == i Ġor Ġk == j : Ġcontinue ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġdx , Ġdy Ġ= Ġp [k ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġdx Ġ- Ġbx Ġ>= Ġ 2 . 0 : Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġ( ex Ġ- Ġdx )** 2 Ġ+ Ġ( ey Ġ- Ġdy )** 2 Ġ<= Ġ 1 . 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ= Ġmax (ans , Ġcount )ĊĊ ĠĠĠ Ġprint (ans )


Input:
def solve():

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

  _S = input()

  S = []

  b = _S[0]

  s = 0

  if b == '0': S.append(0)

  for _s in _S:

    if b == _s:

      s = s + 1

    else:

      b = _s

      S.append(s)

      s = 1

  S.append(s)

  if b == '0': S.append(0)

  num = min(len(S), 2 * K + 1)

  # n = sum(S[0:num if _S[0] == '1' else (num - 1)])

  n = sum(S[0:num])

  m = n

  # for i in range(0 if _S[0] == '1' else -1, len(S) - num, 2):

  for i in range(0, len(S) - num, 2):

    n = n - sum(S[i:i+2])

    n = n + sum(S[i + num:i + num + 2])

    m = max(m, n)

  return m

print((solve()))

def Ġsolve ():ĊĊ Ġ ĠN , ĠK Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ Ġ Ġ_ S Ġ= Ġinput ()ĊĊ Ġ ĠS Ġ= Ġ[]ĊĊ Ġ Ġb Ġ= Ġ_ S [ 0 ]ĊĊ Ġ Ġs Ġ= Ġ 0 ĊĊ Ġ Ġif Ġb Ġ== Ġ' 0 ': ĠS .append ( 0 )ĊĊ Ġ Ġfor Ġ_ s Ġin Ġ_ S :ĊĊ ĠĠĠ Ġif Ġb Ġ== Ġ_ s :ĊĊ ĠĠĠĠĠ Ġs Ġ= Ġs Ġ+ Ġ 1 ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠ Ġb Ġ= Ġ_ s ĊĊ ĠĠĠĠĠ ĠS .append (s )ĊĊ ĠĠĠĠĠ Ġs Ġ= Ġ 1 ĊĊ Ġ ĠS .append (s )ĊĊ Ġ Ġif Ġb Ġ== Ġ' 0 ': ĠS .append ( 0 )ĊĊĊĊ Ġ Ġnum Ġ= Ġmin (len (S ), Ġ 2 Ġ* ĠK Ġ+ Ġ 1 )ĊĊ Ġ Ġ# Ġn Ġ= Ġsum (S [ 0 :num Ġif Ġ_ S [ 0 ] Ġ== Ġ' 1 ' Ġelse Ġ( num Ġ- Ġ 1 )])ĊĊ Ġ Ġn Ġ= Ġsum (S [ 0 :num ])ĊĊ Ġ Ġm Ġ= Ġn ĊĊ Ġ Ġ# Ġfor Ġi Ġin Ġrange ( 0 Ġif Ġ_ S [ 0 ] Ġ== Ġ' 1 ' Ġelse Ġ- 1 , Ġlen (S ) Ġ- Ġnum , Ġ 2 ):ĊĊ Ġ Ġfor Ġi Ġin Ġrange ( 0 , Ġlen (S ) Ġ- Ġnum , Ġ 2 ):ĊĊ ĠĠĠ Ġn Ġ= Ġn Ġ- Ġsum (S [i :i + 2 ])ĊĊ ĠĠĠ Ġn Ġ= Ġn Ġ+ Ġsum (S [i Ġ+ Ġnum :i Ġ+ Ġnum Ġ+ Ġ 2 ])ĊĊ ĠĠĠ Ġm Ġ= Ġmax (m , Ġn )ĊĊĊĊ Ġ Ġreturn Ġm ĊĊĊĊ print (( solve ()))


Input:
import math

N = int(input())

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

print(ans)

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


Input:
#python3

INF = int(1e9)

def main():

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

    ans = INF

    for i in range(2*10**5+100):

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

        ans = min(ans, t)

    print(ans)

main()

# python 3 ĊĊ INF Ġ= Ġint ( 1 e 9 )ĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġa , Ġb , Ġc , Ġx , Ġy Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġans Ġ= ĠINF ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 2 * 1 0 ** 5 + 1 0 0 ):ĊĊ ĠĠĠĠĠĠĠ Ġt Ġ= Ġ 2 *c *i Ġ+ Ġmax (x -i , Ġ 0 ) Ġ* Ġa Ġ+ Ġmax (y -i , Ġ 0 ) Ġ* Ġb ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ= Ġmin (ans , Ġt )ĊĊ ĠĠĠ Ġprint (ans )ĊĊ main ()


Input:
from functools import reduce

N = int(input())

prime_table = [1] * (N+1)

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

    for t in range(2, x+1):

        while x % t == 0:

            prime_table[t] += 1

            x //= t

print((reduce(lambda x, y: x * y % (int(1e9) + 7), prime_table)))

from Ġfunctools Ġimport Ġreduce ĊĊ N Ġ= Ġint (input ())ĊĊ ĊĊ prime _table Ġ= Ġ[ 1 ] Ġ* Ġ( N + 1 )ĊĊĊĊ for Ġx Ġin Ġrange ( 2 , ĠN + 1 ):ĊĊ ĠĠĠ Ġfor Ġt Ġin Ġrange ( 2 , Ġx + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġx Ġ% Ġt Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprime _table [t ] Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġx Ġ//= Ġt ĊĊ print (( reduce (lambda Ġx , Ġy : Ġx Ġ* Ġy Ġ% Ġ( int ( 1 e 9 ) Ġ+ Ġ 7 ), Ġprime _table )))


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

ans = 0

for i in range(K+1):

	for j in range(K+1):

		if (S - i - j) <= K and (S-i-j) >= 0:

			ans += 1

print(ans)

K ,S Ġ= Ġlist (map (int ,input (). split (" Ġ" )))ĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (K + 1 ):ĊĊ ĉfor Ġj Ġin Ġrange (K + 1 ):ĊĊ ĉ ĉif Ġ( S Ġ- Ġi Ġ- Ġj ) Ġ<= ĠK Ġand Ġ( S -i -j ) Ġ>= Ġ 0 :ĊĊ ĉĉ ĉans Ġ+= Ġ 1 ĊĊĊĊ print (ans )Ċ


Input:
while 1:

    ans=0

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

    if n:

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

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

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

                    if i+j+k==x:ans+=1

    else:break

    print(ans)

while Ġ 1 :ĊĊ ĠĠĠ Ġans = 0 ĊĊ ĠĠĠ Ġn ,x =list (map (int ,input (). split ()))ĊĊ ĠĠĠ Ġif Ġn :ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 ,n - 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange (i + 1 ,n ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġk Ġin Ġrange (j + 1 ,n + 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġi +j +k == x : ans += 1 ĊĊ ĠĠĠ Ġelse : break ĊĊ ĠĠĠ Ġprint (ans )


Input:
def main():

  from statistics import mean

  from math import floor,ceil

  n = int(input())

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

  x_mean = mean(x)

  if x_mean == 0.5:

      greater_than_x = len([i for i in x if i > x_mean])

      if greater_than_x * 2 >= n:

          x_mean = ceil(x_mean)

      else:

          x_mean = floor(x_mean)

  elif x_mean % 1 > 0.5:

      x_mean = ceil(x_mean)

  else:

      x_mean = floor(x_mean)

  x2 = [(num - x_mean)**2 for num in x]

  print((sum(x2)))

main()

def Ġmain ():ĊĊ Ġ Ġfrom Ġstatistics Ġimport Ġmean ĊĊ Ġ Ġfrom Ġmath Ġimport Ġfloor , ceil ĊĊĊĊ Ġ Ġn Ġ= Ġint (input ())ĊĊ Ġ Ġx Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ Ġ Ġx _mean Ġ= Ġmean (x ) ĠĊĊ Ġ Ġif Ġx _mean Ġ== Ġ 0 . 5 :ĊĊ ĠĠĠĠĠ Ġgreater _than _x Ġ= Ġlen ([ i Ġfor Ġi Ġin Ġx Ġif Ġi Ġ> Ġx _mean ])ĊĊ ĠĠĠĠĠ Ġif Ġgreater _than _x Ġ* Ġ 2 Ġ>= Ġn :ĊĊ ĠĠĠĠĠĠĠĠĠ Ġx _mean Ġ= Ġceil (x _mean )ĊĊ ĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠ Ġx _mean Ġ= Ġfloor (x _mean )ĊĊ Ġ Ġelif Ġx _mean Ġ% Ġ 1 Ġ> Ġ 0 . 5 :ĊĊ ĠĠĠĠĠ Ġx _mean Ġ= Ġceil (x _mean )ĊĊ Ġ Ġelse :ĊĊ ĠĠĠĠĠ Ġx _mean Ġ= Ġfloor (x _mean )ĊĊ Ġ Ġx 2 Ġ= Ġ[( num Ġ- Ġx _mean )** 2 Ġfor Ġnum Ġin Ġx ]ĊĊ Ġ Ġprint (( sum (x 2 )) )ĊĊĊĊ main ()


Input:
import sys

sys.setrecursionlimit(10 ** 6)

def solve():

    S = input()

    # print(S, len(S))

    words = {0: "dream", 1: "dreamer", 2: "erase", 3: "eraser"}

    TABLE = [[-1 for x in range(len(S) + 1)] for y in range(len(words) + 1)]

    def recur(i, w):

        if not TABLE[w][i] == -1:

            return TABLE[w][i]

        if i >= len(S):

            # print("jey", log)

            return True

        r1, r2, r3, r4 = False, False, False, False

        if S[i:i + 5] == words[0]:

            r1 = recur(i + 5, 0)

        if S[i:i + 7] == words[1]:

            r2 = recur(i + 7, 1)

        if S[i:i + 5] == words[2]:

            r3 = recur(i + 5, 2)

        if S[i:i + 6] == words[3]:

            r4 = recur(i + 6, 3)

        TABLE[w][i] = r1 or r2 or r3 or r4 or False

        return TABLE[w][i]

    ans = recur(0, 0)

    return ans

if __name__ == '__main__':

    res = solve()

    if res:

        print("YES")

    else:

        print("NO")

import Ġsys ĊĊ sys .set rec ursion limit ( 1 0 Ġ** Ġ 6 )ĊĊĊĊĊĊ def Ġsolve ():ĊĊ ĠĠĠ ĠS Ġ= Ġinput ()ĊĊ ĠĠĠ Ġ# Ġprint (S , Ġlen (S )) ĊĊĊĊ ĠĠĠ Ġwords Ġ= Ġ{ 0 : Ġ" dream ", Ġ 1 : Ġ" dream er ", Ġ 2 : Ġ" erase ", Ġ 3 : Ġ" eras er " }ĊĊĊĊ ĠĠĠ ĠTABLE Ġ= Ġ[[ - 1 Ġfor Ġx Ġin Ġrange (len (S ) Ġ+ Ġ 1 )] Ġfor Ġy Ġin Ġrange (len (words ) Ġ+ Ġ 1 )] ĊĊĊĊ ĠĠĠ Ġdef Ġrecur (i , Ġw ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġnot ĠTABLE [w ][ i ] Ġ== Ġ- 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn ĠTABLE [w ][ i ]ĊĊĊĊ ĠĠĠĠĠĠĠ Ġif Ġi Ġ>= Ġlen (S ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġ# Ġprint (" j ey ", Ġlog )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn ĠTrue ĊĊĊĊ ĠĠĠĠĠĠĠ Ġr 1 , Ġr 2 , Ġr 3 , Ġr 4 Ġ= ĠFalse , ĠFalse , ĠFalse , ĠFalse ĊĊ ĠĠĠĠĠĠĠ Ġif ĠS [i :i Ġ+ Ġ 5 ] Ġ== Ġwords [ 0 ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġr 1 Ġ= Ġrecur (i Ġ+ Ġ 5 , Ġ 0 )ĊĊ ĠĠĠĠĠĠĠ Ġif ĠS [i :i Ġ+ Ġ 7 ] Ġ== Ġwords [ 1 ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġr 2 Ġ= Ġrecur (i Ġ+ Ġ 7 , Ġ 1 )ĊĊ ĠĠĠĠĠĠĠ Ġif ĠS [i :i Ġ+ Ġ 5 ] Ġ== Ġwords [ 2 ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġr 3 Ġ= Ġrecur (i Ġ+ Ġ 5 , Ġ 2 )ĊĊ ĠĠĠĠĠĠĠ Ġif ĠS [i :i Ġ+ Ġ 6 ] Ġ== Ġwords [ 3 ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġr 4 Ġ= Ġrecur (i Ġ+ Ġ 6 , Ġ 3 )ĊĊĊĊ ĠĠĠĠĠĠĠ ĠTABLE [w ][ i ] Ġ= Ġr 1 Ġor Ġr 2 Ġor Ġr 3 Ġor Ġr 4 Ġor ĠFalse ĊĊĊĊ ĠĠĠĠĠĠĠ Ġreturn ĠTABLE [w ][ i ]ĊĊĊĊ ĠĠĠ Ġans Ġ= Ġrecur ( 0 , Ġ 0 )ĊĊĊĊ ĠĠĠ Ġreturn Ġans ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġres Ġ= Ġsolve ()ĊĊ ĠĠĠ Ġif Ġres :ĊĊ ĠĠĠĠĠĠĠ Ġprint (" YES ")ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġprint (" NO ")Ċ


Input:
from collections import defaultdict

N = int(input())

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

A.sort()

d = defaultdict(int)

for a in A:

    d[a] += 1

l = sorted(d.items())

max_v = 0

for _, v in l:

    if v > max_v:

        max_v = v

for k, v in l:

    if v == max_v:

        print(k)

    else:

        continue

from Ġcollections Ġimport Ġdefaultdict ĊĊĊĊ N Ġ= Ġint (input ())ĊĊ A Ġ= Ġ[ input () Ġfor Ġ_ Ġin Ġrange (N )]ĊĊ A .sort ()ĊĊ d Ġ= Ġdefaultdict (int )ĊĊ for Ġa Ġin ĠA :ĊĊ ĠĠĠ Ġd [a ] Ġ+= Ġ 1 ĊĊĊĊ l Ġ= Ġsorted (d .items ())ĊĊ max _v Ġ= Ġ 0 ĊĊĊĊ for Ġ_, Ġv Ġin Ġl :ĊĊ ĠĠĠ Ġif Ġv Ġ> Ġmax _v :ĊĊ ĠĠĠĠĠĠĠ Ġmax _v Ġ= Ġv ĊĊ ĠĠĠĠĊĊ for Ġk , Ġv Ġin Ġl :ĊĊ ĠĠĠ Ġif Ġv Ġ== Ġmax _v :ĊĊ ĠĠĠĠĠĠĠ Ġprint (k )ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġcontinue Ċ


Input:
n = int(input())

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

a_index = []

for i in range(n):

    a_index.append((i, a[i]))

dic1 = {}

dic2 = {}

for i in range(n):

    one = a_index[i][0] + a_index[i][1]

    two = a_index[i][0] - a_index[i][1]

    if one not in dic1:

        dic1[one] = 1

    else:

        dic1[one] += 1

    if two not in dic2:

        dic2[two] = 1

    else:

        dic2[two] += 1

ans = 0

for i in list(dic1.keys()):

    if i in dic2:

        ans += dic2[i] * dic1[i]

for i in list(dic2.keys()):

    if i in dic1:

        ans += dic1[i] * dic2[i]

        #print(i)

print((ans // 2))

n Ġ= Ġint (input ())ĊĊ a Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ a _index Ġ= Ġ[]ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġa _index .append (( i , Ġa [i ]))ĊĊ dic 1 Ġ= Ġ{}ĊĊ dic 2 Ġ= Ġ{}ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġone Ġ= Ġa _index [i ][ 0 ] Ġ+ Ġa _index [i ][ 1 ]ĊĊ ĠĠĠ Ġtwo Ġ= Ġa _index [i ][ 0 ] Ġ- Ġa _index [i ][ 1 ]ĊĊ ĠĠĠ Ġif Ġone Ġnot Ġin Ġdic 1 :ĊĊ ĠĠĠĠĠĠĠ Ġdic 1 [ one ] Ġ= Ġ 1 ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġdic 1 [ one ] Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġif Ġtwo Ġnot Ġin Ġdic 2 :ĊĊ ĠĠĠĠĠĠĠ Ġdic 2 [t wo ] Ġ= Ġ 1 ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġdic 2 [t wo ] Ġ+= Ġ 1 ĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġlist (dic 1 .keys ()) :ĊĊ ĠĠĠ Ġif Ġi Ġin Ġdic 2 :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġdic 2 [i ] Ġ* Ġdic 1 [i ]ĊĊ for Ġi Ġin Ġlist (dic 2 .keys ()) :ĊĊ ĠĠĠ Ġif Ġi Ġin Ġdic 1 :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġdic 1 [i ] Ġ* Ġdic 2 [i ]ĊĊ ĠĠĠĠĠĠĠ Ġ# print (i )ĊĊ print (( ans Ġ// Ġ 2 ))Ċ


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

ans=chk=0

for i in range(k+1):

    for j in range(k+1):

        if (0<=s-i-j<=k): ans+=1

print(ans)

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


Input:
N,K = int(input()), int(input())

now = 1

for i in range(N):

    if now*2 < now + K:

        now *= 2

    else:

        now += K

print(now)

N ,K Ġ= Ġint (input ()), Ġint (input ())ĊĊ now Ġ= Ġ 1 ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġif Ġnow * 2 Ġ< Ġnow Ġ+ ĠK :ĊĊ ĠĠĠĠĠĠĠ Ġnow Ġ*= Ġ 2 ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġnow Ġ+= ĠK ĊĊ print (now )Ċ


Input:
import math

n=int(input())

ans=n

i=1

while(i<=math.sqrt(n)):

    if n%i==0:

        d=i+n/i-2

        ans=min(ans,d)

    i+=1

print((int(ans)))

import Ġmath ĊĊ n =int (input ())ĊĊ ans =n ĊĊ i = 1 ĊĊ while (i <= math .sqrt (n )) :ĊĊ ĠĠĠ Ġif Ġn %i == 0 :ĊĊ ĠĠĠĠĠĠĠ Ġd =i +n /i - 2 ĊĊ ĠĠĠĠĠĠĠ Ġans =min (ans ,d )ĊĊ ĠĠĠ Ġi += 1 ĊĊ print (( int (ans )))


Input:
import math

N = int(input())

power = math.factorial(N)

print((power % 1000000007))

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


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

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

dp = ["Second"] * (k + 1)

for i in range(k + 1):

    if dp[i] == "Second":

        for a in a_s:

            ii = i + a

            if ii <= k:

                dp[ii] = "First"

print((dp[-1]))

n , Ġk Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ a _s Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ dp Ġ= Ġ[" Second "] Ġ* Ġ( k Ġ+ Ġ 1 )ĊĊ for Ġi Ġin Ġrange (k Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġif Ġdp [i ] Ġ== Ġ" Second ":ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġa Ġin Ġa _s :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġii Ġ= Ġi Ġ+ Ġa ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġii Ġ<= Ġk :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġdp [ii ] Ġ= Ġ" First "ĊĊ print (( dp [- 1 ]))Ċ


Input:
S, T = [list(input()) for _ in range(2)]

cnt = 0

for i in range(len(S)):

    if S[i] != T[i]:

        cnt += 1

print(cnt)

S , ĠT Ġ= Ġ[ list (input ()) Ġfor Ġ_ Ġin Ġrange ( 2 )]ĊĊ cnt Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (len (S )) :ĊĊ ĠĠĠ Ġif ĠS [i ] Ġ!= ĠT [i ]:ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ print (cnt )Ċ


Input:
N = int(input())

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

cnt = 0

for i in range(N-1):

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

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

print(cnt)

N Ġ= Ġint (input ())ĊĊ D Ġ= Ġlist (map (int ,input (). split ()))ĊĊ cnt Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (N - 1 ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (i + 1 ,N ):ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= ĠD [i ]* D [j ]ĊĊ print (cnt )


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

mn = [0]*N

for i in range(N):

  mn[i] = int(input())

ans = N

x = X - sum(mn)

while(x >= min(mn)):

  if x // min(mn) == 0:

    mn[mn.index(min(mn))] = 1000000

  else:

    if x >= min(mn):

      x -= min(mn)

      ans += 1

print(ans)

N , ĠX Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ mn Ġ= Ġ[ 0 ]* N ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ Ġ Ġmn [i ] Ġ= Ġint (input ())ĊĊ ĠĠĊĊ ans Ġ= ĠN ĊĊ x Ġ= ĠX Ġ- Ġsum (m n )ĊĊĊĊ while (x Ġ>= Ġmin (m n )) :ĊĊ Ġ Ġif Ġx Ġ// Ġmin (m n ) Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġmn [m n .index (min (m n ))] Ġ= Ġ 1 0 0 0 0 0 0 ĊĊ Ġ Ġelse :ĊĊ ĠĠĠ Ġif Ġx Ġ>= Ġmin (m n ):ĊĊ ĠĠĠĠĠ Ġx Ġ-= Ġmin (m n )ĊĊ ĠĠĠĠĠ Ġans Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĊĊ print (ans )


Input:
#! /usr/bin/env python3

import sys

int1 = lambda x: int(x) - 1

read = sys.stdin.buffer.read

readline = sys.stdin.buffer.readline

readlines = sys.stdin.buffer.readlines

sys.setrecursionlimit(500000)

def isMultiple(s, m):

    tmp = 0

    for i in range(len(s)):

        tmp = (tmp * 10 + int(s[i])) % m

        if tmp == 0:

            return i

    return -1

k = int(readline())

acc = "7" * 50000000

if k % 2 == 0:

    ans = -1

else:

    ans = isMultiple(acc, k)

    if ans != -1:

        ans += 1

print(ans)

#! Ġ/ usr /bin /env Ġpython 3 ĊĊĊĊ import Ġsys ĊĊ int 1 Ġ= Ġlambda Ġx : Ġint (x ) Ġ- Ġ 1 ĊĊ read Ġ= Ġsys .stdin .buffer .read ĊĊ read line Ġ= Ġsys .stdin .buffer .readline ĊĊ read lines Ġ= Ġsys .stdin .buffer .readlines ĊĊ sys .set rec ursion limit ( 5 0 0 0 0 0 )ĊĊĊĊĊĊ def Ġis Multiple (s , Ġm ):ĊĊ ĠĠĠ Ġtmp Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (len (s )) :ĊĊ ĠĠĠĠĠĠĠ Ġtmp Ġ= Ġ( tmp Ġ* Ġ 1 0 Ġ+ Ġint (s [i ])) Ġ% Ġm ĊĊ ĠĠĠĠĠĠĠ Ġif Ġtmp Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġi ĊĊ ĠĠĠ Ġreturn Ġ- 1 ĊĊĊĊĊĊ k Ġ= Ġint (read line ())ĊĊ acc Ġ= Ġ" 7 " Ġ* Ġ 5 0 0 0 0 0 0 0 ĊĊ if Ġk Ġ% Ġ 2 Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġans Ġ= Ġ- 1 ĊĊ else :ĊĊĊĊ ĠĠĠ Ġans Ġ= Ġis Multiple (acc , Ġk )ĊĊ ĠĠĠ Ġif Ġans Ġ!= Ġ- 1 :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġ 1 ĊĊĊĊ print (ans )Ċ


Input: n,*l=list(map(int,open(0).read().split()));print((sum(sorted(l*2)[-2:~n:-1])))

n ,* l =list (map (int , open ( 0 ). read (). split ())); print (( sum (sorted (l * 2 )[- 2 : ~ n :- 1 ])))


Input:
import math

N = int(input())

for i in range(int(math.sqrt(N))):

    if N % (int(math.sqrt(N))-i) == 0:

        print((int(N/(int(math.sqrt(N))-i)+int(math.sqrt(N))-i-2)))

        break

import Ġmath ĊĊ N Ġ= Ġint (input ())ĊĊ for Ġi Ġin Ġrange (int (math .sqrt (N ))) :ĊĊ ĠĠĠ Ġif ĠN Ġ% Ġ( int (math .sqrt (N ))- i ) Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġprint (( int (N /( int (math .sqrt (N ))- i )+ int (math .sqrt (N ))- i - 2 )))ĊĊ ĠĠĠĠĠĠĠ Ġbreak


Input:
N, L = [int(i) for i in input().split()]

min_ = L

max_ = L + N -1

def eat_apple():

    if max_<0:

        return max_

    if L < 0:

        return 0

    return L

print(((min_+max_)*(max_-min_+1)//2 - eat_apple()))

N , ĠL Ġ= Ġ[ int (i ) Ġfor Ġi Ġin Ġinput (). split ()] ĊĊĊĊ min _ Ġ= ĠL ĊĊ max _ Ġ= ĠL Ġ+ ĠN Ġ- 1 ĊĊĊĊ def Ġeat _app le ():ĊĊ ĠĠĠ Ġif Ġmax _< 0 :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġmax _ ĠĊĊ ĠĠĠ Ġif ĠL Ġ< Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ 0 ĊĊ ĠĠĠ Ġreturn ĠL ĊĊĊĊ print ((( min _ + max _ )*( max _- min _ + 1 )// 2 Ġ- Ġeat _app le ()))


Input:
from collections import Counter

N = int(input())

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

ans = 0

ruisekiwa = [0] * (N+1)

for i in range(N):

    ruisekiwa[i+1] = ruisekiwa[i] + inputs[i]

ruisekiwa = ruisekiwa[1:]

ruisekiwa.sort()

counter_ruiseki = Counter(ruisekiwa)

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

    if key == 0 and value == 1:

        ans += value

        continue

    elif key == 0 and value > 1:

        ans += value

    if value > 1:

        ans += sum(list(range(value)))

print(ans)

from Ġcollections Ġimport ĠCounter ĊĊĊĊ N Ġ= Ġint (input ())ĊĊ inputs Ġ= Ġ[ int (i ) Ġfor Ġi Ġin Ġinput (). split ()] ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ ruise ki wa Ġ= Ġ[ 0 ] Ġ* Ġ( N + 1 )ĊĊĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġru ise ki wa [i + 1 ] Ġ= Ġru ise ki wa [i ] Ġ+ Ġinputs [i ]ĊĊĊĊ ruise ki wa Ġ= Ġru ise ki wa [ 1 :]ĊĊ ruise ki wa .sort ()ĊĊ counter _ru ise ki Ġ= ĠCounter (r u ise ki wa )ĊĊĊĊ for Ġkey , Ġvalue Ġin Ġlist (counter _ru ise ki .items ()) :ĊĊ ĠĠĠ Ġif Ġkey Ġ== Ġ 0 Ġand Ġvalue Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġvalue ĊĊ ĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠ Ġelif Ġkey Ġ== Ġ 0 Ġand Ġvalue Ġ> Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġvalue ĊĊ ĠĠĠ Ġif Ġvalue Ġ> Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġsum (list (range (value )) )ĊĊĊĊ print (ans )Ċ


Input:
import sys

_input = sys.stdin.readline

def resolve():

    N = int(_input())

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

    t, x, y = 0, 0, 0

    for next_t, next_x, next_y in T:

        diff_xy = abs(x - next_x) + abs(y - next_y)

        diff_t = next_t - t

        if diff_xy > diff_t or (diff_xy % 2 != diff_t % 2):

            print('No')

            exit(0)

    print('Yes')

if __name__ == '__main__':

    resolve()

import Ġsys ĊĊ _input Ġ= Ġsys .stdin .readline ĊĊĊĊĊĊ def Ġresolve ():ĊĊ ĠĠĠ ĠN Ġ= Ġint (_ input ())ĊĊ ĠĠĠ ĠT Ġ= Ġ[ list (map (int , Ġ_ input (). split ())) Ġfor Ġ_ Ġin Ġrange (N )]ĊĊ ĠĠĠ Ġt , Ġx , Ġy Ġ= Ġ 0 , Ġ 0 , Ġ 0 ĊĊ ĠĠĠ Ġfor Ġnext _t , Ġnext _x , Ġnext _y Ġin ĠT :ĊĊ ĠĠĠĠĠĠĠ Ġdiff _xy Ġ= Ġabs (x Ġ- Ġnext _x ) Ġ+ Ġabs (y Ġ- Ġnext _y )ĊĊ ĠĠĠĠĠĠĠ Ġdiff _t Ġ= Ġnext _t Ġ- Ġt ĊĊ ĠĠĠĠĠĠĠ Ġif Ġdiff _xy Ġ> Ġdiff _t Ġor Ġ( diff _xy Ġ% Ġ 2 Ġ!= Ġdiff _t Ġ% Ġ 2 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (' No ')ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġexit ( 0 )ĊĊ ĠĠĠ Ġprint (' Yes ')ĊĊ ĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġresolve ()


Input:
S = [int(_) for _ in input()]

length = len(S)

temp = [S[0]]

for x in S[1:]:

    if(len(temp) == 0):

        temp.append(x)

    elif( temp[-1] == x):

        temp.append(x)

    else:

        temp.pop(-1)

print((length-len(temp)))

S Ġ= Ġ[ int (_) Ġfor Ġ_ Ġin Ġinput ()]ĊĊ length Ġ= Ġlen (S )ĊĊ temp Ġ= Ġ[ S [ 0 ]]ĊĊ for Ġx Ġin ĠS [ 1 :] :ĊĊ ĠĠĠ Ġif (len (temp ) Ġ== Ġ 0 ):ĊĊ ĠĠĠĠĠĠĠ Ġtemp .append (x )ĊĊ ĠĠĠ Ġelif ( Ġtemp [- 1 ] Ġ== Ġx ):ĊĊ ĠĠĠĠĠĠĠ Ġtemp .append (x )ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġtemp .pop (- 1 )ĊĊ print (( length -len (temp )))ĊĊ ĠĠĠĠĠĠĠĠ


Input:
K = int(input())

flg = [False]*K

tmp = 7 % K

cnt = 1

if tmp == 0:

    print(cnt)

    exit()

while True:

    tmp = (tmp*10+7)%K

    if flg[tmp]:

        print((-1))

        break

    else:

        cnt += 1

        if tmp == 0:

            print(cnt)

            break

        flg[tmp] = True

K Ġ= Ġint (input ())ĊĊ ĊĊ fl g Ġ= Ġ[ False ]* K ĊĊĊĊ tmp Ġ= Ġ 7 Ġ% ĠK ĊĊ cnt Ġ= Ġ 1 ĊĊ if Ġtmp Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġprint (cnt )ĊĊ ĠĠĠ Ġexit ()ĊĊ while ĠTrue :ĊĊ ĠĠĠ Ġtmp Ġ= Ġ( tmp * 1 0 + 7 )% K ĊĊ ĠĠĠ Ġif Ġfl g [tmp ]:ĊĊ ĠĠĠĠĠĠĠ Ġprint ((- 1 ))ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġif Ġtmp Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (cnt )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠ Ġfl g [tmp ] Ġ= ĠTrue Ċ


Input:
from math import factorial

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

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


Input:
import sys

sys.setrecursionlimit(202020)

N = int(input())

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

for i in range(1,N):

    a = int(input()) - 1

    won[a].append(i)

def height(v):

    if not won[v]: return 0

    hs = [height(op) for op in won[v]]

    ret = 0

    for i,h in enumerate(sorted(hs)):

        ret = max(ret, h + len(hs) - i)

    return ret

print((height(0)))

import Ġsys ĊĊ sys .set rec ursion limit ( 2 0 2 0 2 0 )ĊĊĊĊ N Ġ= Ġint (input ())ĊĊ won Ġ= Ġ[[] Ġfor Ġi Ġin Ġrange (N )]ĊĊ for Ġi Ġin Ġrange ( 1 ,N ):ĊĊ ĠĠĠ Ġa Ġ= Ġint (input ()) Ġ- Ġ 1 ĊĊ ĠĠĠ Ġwon [a ]. append (i )ĊĊĊĊ def Ġheight (v ):ĊĊ ĠĠĠ Ġif Ġnot Ġwon [v ]: Ġreturn Ġ 0 ĊĊ ĠĠĠ Ġhs Ġ= Ġ[ height (op ) Ġfor Ġop Ġin Ġwon [v ]]ĊĊ ĠĠĠ Ġret Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi ,h Ġin Ġenumerate (sorted (h s )) :ĊĊ ĠĠĠĠĠĠĠ Ġret Ġ= Ġmax (ret , Ġh Ġ+ Ġlen (h s ) Ġ- Ġi )ĊĊ ĠĠĠ Ġreturn Ġret ĊĊĊĊ print (( height ( 0 )))


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

count = 0

for i in range(N):

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

    if (a**2 + b**2) <= D**2:

        count += 1

print(count)

N , ĠD Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ count Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġa , Ġb Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġif Ġ( a ** 2 Ġ+ Ġb ** 2 ) Ġ<= ĠD ** 2 :ĊĊ ĠĠĠĠĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊ print (count )Ċ


Input:
# ABC102C - Linear Approximation (ARC100C)

from statistics import median

def main():

    n = int(input())

    A = tuple(map(int, input().rstrip().split()))

    A = tuple(j - i for i, j in enumerate(A, start=1))

    b = median(A)

    ans = sum(abs(a - b) for a in A)

    print((int(ans)))

if __name__ == "__main__":

    main()

# ĠABC 1 0 2 C Ġ- ĠLinear ĠApprox imation Ġ( ARC 1 0 0 C )ĊĊ from Ġstatistics Ġimport Ġmedian ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġn Ġ= Ġint (input ())ĊĊ ĠĠĠ ĠA Ġ= Ġtuple (map (int , Ġinput (). rstrip (). split ()))ĊĊ ĠĠĠ ĠA Ġ= Ġtuple (j Ġ- Ġi Ġfor Ġi , Ġj Ġin Ġenumerate (A , Ġstart = 1 ))ĊĊ ĠĠĠ Ġb Ġ= Ġmedian (A )ĊĊ ĠĠĠ Ġans Ġ= Ġsum (abs (a Ġ- Ġb ) Ġfor Ġa Ġin ĠA )ĊĊ ĠĠĠ Ġprint (( int (ans )))ĊĊ ĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġmain ()


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

L = {el: 1 for el in [a, b, c, d, e, 0]}

for i in range(6):

    R = sorted(L.items(), key=lambda x: x[1])

    for p, l in R:

        if l < 16:

            L[p ^ e] = min(L.get(p ^ e, 16), l+1)

            if l+3 < 16:

                for q, r in R:

                    if l+r+3 <= 16:

                        L[p & q] = min(L.get(p & q, 16), l+r+3)

                        L[p ^ q] = min(L.get(p ^ q, 16), l+r+3)

                    else: break

        else: break

print(*(L[e & eval(s)] for s in 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 ĊĊ L Ġ= Ġ{ el : Ġ 1 Ġfor Ġel Ġin Ġ[ a , Ġb , Ġc , Ġd , Ġe , Ġ 0 ] }ĊĊ for Ġi Ġin Ġrange ( 6 ):ĊĊ ĠĠĠ ĠR Ġ= Ġsorted (L .items (), Ġkey =lambda Ġx : Ġx [ 1 ])ĊĊ ĠĠĠ Ġfor Ġp , Ġl Ġin ĠR :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġl Ġ< Ġ 1 6 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠL [p Ġ^ Ġe ] Ġ= Ġmin (L .get (p Ġ^ Ġe , Ġ 1 6 ), Ġl + 1 )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġl + 3 Ġ< Ġ 1 6 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġq , Ġr Ġin ĠR :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġl +r + 3 Ġ<= Ġ 1 6 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ ĠL [p Ġ& Ġq ] Ġ= Ġmin (L .get (p Ġ& Ġq , Ġ 1 6 ), Ġl +r + 3 )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ ĠL [p Ġ^ Ġq ] Ġ= Ġmin (L .get (p Ġ^ Ġq , Ġ 1 6 ), Ġl +r + 3 )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse : Ġbreak ĊĊ ĠĠĠĠĠĠĠ Ġelse : Ġbreak ĊĊ print (*( L [e Ġ& Ġeval (s )] Ġfor Ġs Ġin Ġopen ( 0 ). read (). replace (* "- ~ "). replace (* "* & "). replace (* " 1 e "). split () [:- 1 ]), sep ='\ n ')Ċ


Input:
#python3

from collections import defaultdict

from collections import namedtuple

P = namedtuple('P', ['front', 'end'])

def f(x):

    return P(str(x)[0], str(x)[-1])

def main():

    n = int(input())

    freq = defaultdict(int)

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

        p = f(i)

        freq[p]+=1

    ans = 0

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

        p = f(i)

        q = (p.end, p.front)

        ans += freq[q]

    print(ans)

main()

# python 3 ĊĊ from Ġcollections Ġimport Ġdefaultdict ĊĊ from Ġcollections Ġimport Ġnamedtuple ĊĊĊĊ P Ġ= Ġnamedtuple (' P ', Ġ[' front ', Ġ' end '] )ĊĊĊĊ def Ġf (x ):ĊĊ ĠĠĠ Ġreturn ĠP (str (x )[ 0 ], Ġstr (x )[- 1 ]) ĠĊĊĊĊ def Ġmain (): ĊĊĊĊ ĠĠĠ Ġn Ġ= Ġint (input ())ĊĊ ĠĠĠ Ġfreq Ġ= Ġdefaultdict (int )ĊĊĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 , Ġn + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġp Ġ= Ġf (i )ĊĊ ĠĠĠĠĠĠĠ Ġfreq [p ]+= 1 ĊĊĊĊĊĊ ĠĠĠ Ġans Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 , Ġn Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġp Ġ= Ġf (i )ĊĊ ĠĠĠĠĠĠĠ Ġq Ġ= Ġ( p .end , Ġp .front )ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġfreq [q ]ĊĊĊĊ ĠĠĠ Ġprint (ans )ĊĊĊĊ main ()


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

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

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

bc.sort(key=lambda x: x[1], reverse=True)

a.sort()

i = 0

for b, c in bc:

    for _ in range(b):

        if i < n and a[i] < c:

            a[i] = c

            i += 1

        else:

            break

ans = sum(a)

print(ans)

n , Ġm Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ a Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ bc Ġ= Ġ[ list (map (int , Ġinput (). split ())) Ġfor Ġ_ Ġin Ġrange (m )] ĊĊĊĊ bc .sort (key =lambda Ġx : Ġx [ 1 ], Ġreverse =True )ĊĊ a .sort ()ĊĊĊĊ i Ġ= Ġ 0 ĊĊ for Ġb , Ġc Ġin Ġbc :ĊĊ ĠĠĠ Ġfor Ġ_ Ġin Ġrange (b ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġi Ġ< Ġn Ġand Ġa [i ] Ġ< Ġc :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġa [i ] Ġ= Ġc ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġi Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊĊĊ ans Ġ= Ġsum (a )ĊĊ print (ans )Ċ


Input:
def f(s):

    s=list(map(int,s.split(':')))

    return (s[0]*60+s[1])*60+s[2]

a=86401

while 1:

    t=[0]*a

    n=int(input())

    if n==0:break

    for _ in range(n):

        b,c=input().split()

        t[f(b)]+=1;t[f(c)]-=1

    d=0

    for i in range(1,a):

        t[i]+=t[i-1]

        d=max(d,t[i])

    print(d)

def Ġf (s ):ĊĊ ĠĠĠ Ġs =list (map (int ,s .split (': ')) )ĊĊ ĠĠĠ Ġreturn Ġ( s [ 0 ]* 6 0 +s [ 1 ])* 6 0 +s [ 2 ]ĊĊ a = 8 6 4 0 1 ĊĊ while Ġ 1 :ĊĊ ĠĠĠ Ġt =[ 0 ]* a ĊĊ ĠĠĠ Ġn =int (input ())ĊĊ ĠĠĠ Ġif Ġn == 0 : break ĊĊ ĠĠĠ Ġfor Ġ_ Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠ Ġb ,c =input (). split ()ĊĊ ĠĠĠĠĠĠĠ Ġt [f (b )] += 1 ;t [f (c )] -= 1 ĊĊ ĠĠĠ Ġd = 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 ,a ):ĊĊ ĠĠĠĠĠĠĠ Ġt [i ]+= t [i - 1 ]ĊĊ ĠĠĠĠĠĠĠ Ġd =max (d ,t [i ])ĊĊ ĠĠĠ Ġprint (d )


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

num_one = S.count("1")

num_zero = S.count("0")

ans = min(num_one, num_zero) *2

print(ans)

S Ġ= Ġlist (input ())ĊĊ num _one Ġ= ĠS .count (" 1 ")ĊĊ num _zero Ġ= ĠS .count (" 0 ")ĊĊ ans Ġ= Ġmin (num _one , Ġnum _zero ) Ġ* 2 ĊĊ print (ans )Ċ


Input:
import sys

can = True; input()

e = [[0, 0, 0]] + [list(map(int, e.split())) for e in sys.stdin]

for a, b in zip(e[1:], e):

    t = a[0] - b[0] - abs(a[1] - b[1]) - abs(a[2] - b[2])

    if t < 0 or t % 2 == 1: can = False; break

print((['No', 'Yes'][can]))

import Ġsys ĊĊ can Ġ= ĠTrue ; Ġinput ()ĊĊ e Ġ= Ġ[[ 0 , Ġ 0 , Ġ 0 ]] Ġ+ Ġ[ list (map (int , Ġe .split ())) Ġfor Ġe Ġin Ġsys .stdin ]ĊĊ for Ġa , Ġb Ġin Ġzip (e [ 1 :], Ġe ):ĊĊ ĠĠĠ Ġt Ġ= Ġa [ 0 ] Ġ- Ġb [ 0 ] Ġ- Ġabs (a [ 1 ] Ġ- Ġb [ 1 ]) Ġ- Ġabs (a [ 2 ] Ġ- Ġb [ 2 ])ĊĊ ĠĠĠ Ġif Ġt Ġ< Ġ 0 Ġor Ġt Ġ% Ġ 2 Ġ== Ġ 1 : Ġcan Ġ= ĠFalse ; Ġbreak ĊĊ print (( [' No ', Ġ' Yes '][ can ]))


Input:
import sys

readline = sys.stdin.readline

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

INF = 10 ** 10

dp = [INF] * (2 ** N)

dp[0] = 0

for i in range(M):

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

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

  key = 0

  for j in range(len(c)):

    key += (1 << (c[j] - 1))

  for j in range(len(dp)):

    if dp[j] == INF:

      continue

    if j | key == j:

      continue

    dp[j | key] = min(dp[j | key], dp[j] + a)

if dp[-1] == INF:

  print((-1))

else:

  print((dp[-1]))

import Ġsys ĊĊ read line Ġ= Ġsys .stdin .readline ĊĊĊĊ N ,M Ġ= Ġlist (map (int , read line (). split ()))ĊĊ INF Ġ= Ġ 1 0 Ġ** Ġ 1 0 ĊĊ dp Ġ= Ġ[ INF ] Ġ* Ġ( 2 Ġ** ĠN )ĊĊ dp [ 0 ] Ġ= Ġ 0 ĊĊĊĊ for Ġi Ġin Ġrange (M ):ĊĊ Ġ Ġa ,b Ġ= Ġlist (map (int , read line (). split ()))ĊĊ Ġ Ġc Ġ= Ġlist (map (int , read line (). split ()))ĊĊ Ġ Ġkey Ġ= Ġ 0 ĊĊ Ġ Ġfor Ġj Ġin Ġrange (len (c )) :ĊĊ ĠĠĠ Ġkey Ġ+= Ġ( 1 Ġ<< Ġ( c [j ] Ġ- Ġ 1 ))ĊĊ Ġ Ġfor Ġj Ġin Ġrange (len (dp )) :ĊĊ ĠĠĠ Ġif Ġdp [j ] Ġ== ĠINF :ĊĊ ĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠ Ġif Ġj Ġ| Ġkey Ġ== Ġj :ĊĊ ĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠ Ġdp [j Ġ| Ġkey ] Ġ= Ġmin (dp [j Ġ| Ġkey ], Ġdp [j ] Ġ+ Ġa )ĊĊĊĊ if Ġdp [- 1 ] Ġ== ĠINF :ĊĊ Ġ Ġprint ((- 1 ))ĊĊ else :ĊĊ Ġ Ġprint (( dp [- 1 ]))


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

S = input()

latest = [None]*K

i = len(S)+C

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

  i = S.rindex("o", 0, i-C)

  latest[j] = i

if i<=C or "o" not in S[:i-C]:

  i = -C-1

  for j in latest:

    i = S.index("o", i+C+1)

    if i == j:

      print((i+1))

N , ĠK , ĠC Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ S Ġ= Ġinput ()ĊĊĊĊ latest Ġ= Ġ[ None ]* K ĊĊ i Ġ= Ġlen (S )+ C ĊĊ for Ġj Ġin Ġrange (K - 1 , Ġ- 1 , Ġ- 1 ):ĊĊ Ġ Ġi Ġ= ĠS .r index (" o ", Ġ 0 , Ġi -C )ĊĊ Ġ Ġlatest [j ] Ġ= Ġi ĊĊĊĊ if Ġi <= C Ġor Ġ" o " Ġnot Ġin ĠS [: i -C ]:ĊĊ Ġ Ġi Ġ= Ġ- C - 1 ĊĊ Ġ Ġfor Ġj Ġin Ġlatest :ĊĊ ĠĠĠ Ġi Ġ= ĠS .index (" o ", Ġi +C + 1 )ĊĊ ĠĠĠ Ġif Ġi Ġ== Ġj :ĊĊ ĠĠĠĠĠ Ġprint (( i + 1 ))Ċ


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

sunuke = [True]*N

for i in range(K):

    d = int(input())

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

    for a in A:

        sunuke[a-1] = False

ans = 0

for i in range(N):

    if sunuke[i]:

        ans += 1

print(ans)

N , ĠK Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ sun uke Ġ= Ġ[ True ]* N ĊĊ for Ġi Ġin Ġrange (K ):ĊĊ ĠĠĠ Ġd Ġ= Ġint (input ())ĊĊ ĠĠĠ ĠA Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġfor Ġa Ġin ĠA :ĊĊ ĠĠĠĠĠĠĠ Ġsun uke [a - 1 ] Ġ= ĠFalse ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġif Ġsun uke [i ]:ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġ 1 ĊĊ print (ans )


Input:
import sys

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

def resolve():

    import math

    n=int(input())

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

resolve()

import Ġsys ĊĊ def Ġinput (): Ġreturn Ġsys .stdin .readline (). strip ()ĊĊĊĊ def Ġresolve ():ĊĊ ĠĠĠ Ġimport Ġmath ĊĊ ĠĠĠ Ġn =int (input ())ĊĊ ĠĠĠ Ġprint (( math .factor ial (n ) %( 1 0 ** 9 + 7 )))ĊĊ resolve ()


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

j = 0

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

  l = list(str(i))

  l_reverse = list(reversed(l))

  if l == l_reverse:

    j += 1

print(j)

A ,B Ġ= Ġlist (map (int ,input (). split ()))ĊĊ j Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (A ,B + 1 ):ĊĊ Ġ Ġl Ġ= Ġlist (str (i ))ĊĊ Ġ Ġl _reverse Ġ= Ġlist (re versed (l ))ĊĊ Ġ Ġif Ġl Ġ== Ġl _reverse :ĊĊ ĠĠĠ Ġj Ġ+= Ġ 1 ĊĊ print (j )


Input:
s = int(input())

m, s = s // 60, s % 60

h, m = m // 60, m % 60

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

s Ġ= Ġint (input ())ĊĊ m , Ġs Ġ= Ġs Ġ// Ġ 6 0 , Ġs Ġ% Ġ 6 0 ĊĊ h , Ġm Ġ= Ġm Ġ// Ġ 6 0 , Ġm Ġ% Ġ 6 0 ĊĊ print ( (': '. join (map (str , Ġ[ h ,m ,s ])) ))


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 sys

input = sys.stdin.readline

def main():

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

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

  BIT = [0]*(m+2)

  def add(i, a):

    while i <= m+1:

      BIT[i] += a

      i += i&(-i)

  def bit_sum(i):

    res = 0

    while i > 0:

      res += BIT[i]

      i -= i&(-i)

    return res

  S = sorted([(r-l+1, l, r) for l, r in LR], reverse=True)

  cnt = n

  L = []

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

    while S and S[-1][0] == i:

      c, l, r = S.pop()

      cnt -= 1

      add(l, 1)

      add(r+1, -1)

    res = cnt

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

      res += bit_sum(j)

    L.append(res)

  print(*L, sep="\n")

if __name__ == "__main__":

  main()

import Ġsys ĊĊ input Ġ= Ġsys .stdin .readline ĊĊĊĊ def Ġmain ():ĊĊ Ġ Ġn , Ġm Ġ= Ġmap (int , Ġinput (). split ())ĊĊ Ġ ĠLR Ġ= Ġ[ list (map (int , Ġinput (). split ())) Ġfor Ġ_ Ġin Ġrange (n )]ĊĊ ĠĠĊĊ Ġ ĠBIT Ġ= Ġ[ 0 ]*( m + 2 )ĊĊ Ġ Ġdef Ġadd (i , Ġa ):ĊĊ ĠĠĠ Ġwhile Ġi Ġ<= Ġm + 1 :ĊĊ ĠĠĠĠĠ ĠBIT [i ] Ġ+= Ġa ĊĊ ĠĠĠĠĠ Ġi Ġ+= Ġi & (- i )ĊĊ Ġ Ġdef Ġbit _sum (i ):ĊĊ ĠĠĠ Ġres Ġ= Ġ 0 ĊĊ ĠĠĠ Ġwhile Ġi Ġ> Ġ 0 :ĊĊ ĠĠĠĠĠ Ġres Ġ+= ĠBIT [i ]ĊĊ ĠĠĠĠĠ Ġi Ġ-= Ġi & (- i )ĊĊ ĠĠĠ Ġreturn Ġres ĊĊ ĠĠĊĊ Ġ ĠS Ġ= Ġsorted ([( r -l + 1 , Ġl , Ġr ) Ġfor Ġl , Ġr Ġin ĠLR ], Ġreverse =True )ĊĊ Ġ Ġcnt Ġ= Ġn ĊĊ Ġ ĠL Ġ= Ġ[]ĊĊ Ġ Ġfor Ġi Ġin Ġrange ( 1 , Ġm + 1 ):ĊĊ ĠĠĠ Ġwhile ĠS Ġand ĠS [- 1 ][ 0 ] Ġ== Ġi :ĊĊ ĠĠĠĠĠ Ġc , Ġl , Ġr Ġ= ĠS .pop ()ĊĊ ĠĠĠĠĠ Ġcnt Ġ-= Ġ 1 ĊĊ ĠĠĠĠĠ Ġadd (l , Ġ 1 )ĊĊ ĠĠĠĠĠ Ġadd (r + 1 , Ġ- 1 )ĊĊ ĠĠĠ Ġres Ġ= Ġcnt ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange ( 0 , Ġm + 1 , Ġi ):ĊĊ ĠĠĠĠĠ Ġres Ġ+= Ġbit _sum (j )ĊĊ ĠĠĠ ĠL .append (res )ĊĊ Ġ Ġprint (* L , Ġsep ="\ n ")ĊĊ ĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ Ġ Ġmain ()Ċ


Input:
import functools

print((len(functools.reduce(lambda x, y: x&y,[set(input().split()[1:]) for _ in [0]*int(input().split()[0])]))))

import Ġfunctools ĊĊ print (( len (f unct ools .reduce (lambda Ġx , Ġy : Ġx & y ,[ set (input (). split ()[ 1 :]) Ġfor Ġ_ Ġin Ġ[ 0 ]* int (input (). split ()[ 0 ]) ])) ))


Input:
#!/usr/bin/env python3

# coding=utf-8

import sys

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

l = [_s is "1" for _s in list(s)]

l_r = l[::-1]

index = 0

for i, (c, n, c_r, n_r) in enumerate(

        zip(l[:len(s) // 2], l[1:len(s) // 2 + 1], l_r[:len(s) // 2], l_r[1:len(s) // 2 + 1])):

    if c ^ n or c_r ^ n_r:

        index = i + 1

print((len(s) - index))

#!/ usr /bin /env Ġpython 3 ĊĊ # Ġcoding =utf - 8 ĊĊĊĊ import Ġsys ĊĊĊĊ s Ġ= Ġsys .stdin .readline (). strip ()ĊĊ l Ġ= Ġ[_ s Ġis Ġ" 1 " Ġfor Ġ_ s Ġin Ġlist (s )]ĊĊ l _r Ġ= Ġl [::- 1 ]ĊĊ index Ġ= Ġ 0 ĊĊ for Ġi , Ġ( c , Ġn , Ġc _r , Ġn _r ) Ġin Ġenumerate (ĊĊ ĠĠĠĠĠĠĠ Ġzip (l [: len (s ) Ġ// Ġ 2 ], Ġl [ 1 :len (s ) Ġ// Ġ 2 Ġ+ Ġ 1 ], Ġl _r [: len (s ) Ġ// Ġ 2 ], Ġl _r [ 1 :len (s ) Ġ// Ġ 2 Ġ+ Ġ 1 ])) :ĊĊ ĠĠĠ Ġif Ġc Ġ^ Ġn Ġor Ġc _r Ġ^ Ġn _r :ĊĊ ĠĠĠĠĠĠĠ Ġindex Ġ= Ġi Ġ+ Ġ 1 ĊĊ print (( len (s ) Ġ- Ġindex ))


Input:
N = int(input())

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

SUM = 0

for i in A:

    count = 0

    while i%2 == 0:

        i//=2

        count += 1

    SUM+=count

print(SUM)

N Ġ= Ġint (input ())ĊĊ A Ġ= Ġlist (map (int ,input (). split ())) ĊĊĊĊ SUM Ġ= Ġ 0 ĊĊ for Ġi Ġin ĠA :ĊĊ ĠĠĠ Ġcount Ġ= Ġ 0 ĊĊ ĠĠĠ Ġwhile Ġi % 2 Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġi //= 2 ĊĊ ĠĠĠĠĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊ ĠĠĠ ĠSUM += count ĊĊ print (S UM )


Input:
n = int(input())

INF = 10**9 + 7

ans = [0] * (10**5 + 1)

ans[0] = 1

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

    ans[i] = ans[i-1] * i % INF

print((ans[n]))

n Ġ= Ġint (input ())ĊĊ ĊĊ INF Ġ= Ġ 1 0 ** 9 Ġ+ Ġ 7 ĊĊĊĊ ans Ġ= Ġ[ 0 ] Ġ* Ġ( 1 0 ** 5 Ġ+ Ġ 1 )ĊĊ ans [ 0 ] Ġ= Ġ 1 ĊĊĊĊ for Ġi Ġin Ġrange ( 1 , 1 0 ** 5 Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġans [i ] Ġ= Ġans [i - 1 ] Ġ* Ġi Ġ% ĠINF ĊĊĊĊ print (( ans [n ]))Ċ


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

ans = a * x + b * y

m = max(x, y)

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

  x -= 1

  y -= 1

  if x < 0:

    x = 0

  if y < 0:

    y = 0

  temp = c*(i*2) + x*a + y*b

  if temp < ans:

    ans = temp

print(ans)

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


Input:
n=int(input())

s=input()

x=["SS","SW","WS","WW"]

def check0(i):

    if x[i][0]=="S":

        if s[0]=="o":

            if x[i][-1]=="S":

                return x[i][1]=="S"

            else:

                return x[i][1]=="W"

        else:

            if x[i][-1]=="S":

                return x[i][1]=="W"

            else:

                return x[i][1]=="S"

    else:

        if s[0]=="o":

            if x[i][-1]=="S":

                return x[i][1]=="W"

            else:

                return x[i][1]=="S"

        else:

            if x[i][-1]=="S":

                return x[i][1]=="S"

            else:

                return x[i][1]=="W"

def check1(i):

    if x[i][n-1]=="S":

        if s[n-1]=="o":

            if x[i][n-2]=="S":

                return x[i][0]=="S"

            else:

                return x[i][0]=="W"

        else:

            if x[i][n-2]=="S":

                return x[i][0]=="W"

            else:

                return x[i][0]=="S"

    else:

        if s[n-1]=="o":

            if x[i][n-2]=="S":

                return x[i][0]=="W"

            else:

                return x[i][0]=="S"

        else:

            if x[i][n-2]=="S":

                return x[i][0]=="S"

            else:

                return x[i][0]=="W"

for i in range(4):

    for j in range(n-2):

        if x[i][j+1]=="S":

            if s[j+1]=="o":

                if x[i][j]=="S":

                    x[i]+="S"

                else:

                    x[i]+="W"

            else:

                if x[i][j]=="S":

                    x[i]+="W"

                else:

                    x[i]+="S"

        else:

            if s[j+1]=="o":

                if x[i][j]=="S":

                    x[i]+="W"

                else:

                    x[i]+="S"

            else:

                if x[i][j]=="S":

                    x[i]+="S"

                else:

                    x[i]+="W"

    #print(x[i])

    if check0(i) and check1(i):

        print((x[i]))

        break

else:

    print((-1))

n =int (input ())ĊĊ s =input ()ĊĊ x =[" SS "," SW "," WS "," WW "] ĊĊĊĊ def Ġcheck 0 (i ):ĊĊ ĠĠĠ Ġif Ġx [i ][ 0 ]==" S ":ĊĊ ĠĠĠĠĠĠĠ Ġif Ġs [ 0 ]==" o ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġx [i ][- 1 ]==" S ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 1 ]==" S "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 1 ]==" W "ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġx [i ][- 1 ]==" S ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 1 ]==" W "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 1 ]==" S "ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġs [ 0 ]==" o ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġx [i ][- 1 ]==" S ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 1 ]==" W "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 1 ]==" S "ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġx [i ][- 1 ]==" S ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 1 ]==" S "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 1 ]==" W "ĊĊ def Ġcheck 1 (i ):ĊĊ ĠĠĠ Ġif Ġx [i ][ n - 1 ]==" S ":ĊĊ ĠĠĠĠĠĠĠ Ġif Ġs [n - 1 ]==" o ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġx [i ][ n - 2 ]==" S ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 0 ]==" S "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 0 ]==" W "ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġx [i ][ n - 2 ]==" S ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 0 ]==" W "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 0 ]==" S "ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġs [n - 1 ]==" o ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġx [i ][ n - 2 ]==" S ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 0 ]==" W "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 0 ]==" S "ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġx [i ][ n - 2 ]==" S ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 0 ]==" S "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġx [i ][ 0 ]==" W " ĊĊĊĊĊĊ for Ġi Ġin Ġrange ( 4 ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (n - 2 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġx [i ][ j + 1 ]==" S ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġs [j + 1 ]==" o ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġx [i ][ j ]==" S ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġx [i ]+ =" S "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġx [i ]+ =" W "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġx [i ][ j ]==" S ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġx [i ]+ =" W "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġx [i ]+ =" S "ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġs [j + 1 ]==" o ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġx [i ][ j ]==" S ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġx [i ]+ =" W "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġx [i ]+ =" S "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġx [i ][ j ]==" S ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġx [i ]+ =" S "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġx [i ]+ =" W "ĊĊ ĠĠĠ Ġ# print (x [i ])ĊĊ ĠĠĠ Ġif Ġcheck 0 (i ) Ġand Ġcheck 1 (i ):ĊĊ ĠĠĠĠĠĠĠ Ġprint (( x [i ]))ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊ else :ĊĊ ĠĠĠ Ġprint ((- 1 ))Ċ


Input:
# coding: utf-8

import sys

input = sys.stdin.readline

def f(n, abc):

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

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

        for j in range(3):

            dp[i][j] = max(dp[i - 1][k] + abc[i - 1][j] \

                for k in range(3) if k != j)

    return(max(dp[n]))

n = int(input())    # 1 <= n <= 10^5

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

print((f(n, abc)))

# Ġcoding : Ġutf - 8 ĊĊĊĊ import Ġsys ĊĊ input Ġ= Ġsys .stdin .readline ĊĊĊĊ def Ġf (n , Ġabc ):ĊĊ ĠĠĠ Ġdp Ġ= Ġ[[ 0 ] Ġ* Ġ 3 Ġfor Ġ_ Ġin Ġrange (n Ġ+ Ġ 1 )]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 , Ġn Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange ( 3 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdp [i ][ j ] Ġ= Ġmax (dp [i Ġ- Ġ 1 ][ k ] Ġ+ Ġabc [i Ġ- Ġ 1 ][ j ] Ġ\ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġk Ġin Ġrange ( 3 ) Ġif Ġk Ġ!= Ġj )ĊĊ ĠĠĠ Ġreturn (max (dp [n ])) ĊĊĊĊ n Ġ= Ġint (input ()) ĠĠĠ Ġ# Ġ 1 Ġ<= Ġn Ġ<= Ġ 1 0 ^ 5 ĊĊ abc Ġ= Ġ[ list (map (int , Ġinput (). rstrip (). split ())) Ġfor Ġ_ Ġin Ġrange (n )] ĊĊĊĊ print (( f (n , Ġabc )))Ċ


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

point = []

for i in range(N):

    point.append(list(map(int, input().split())))

ct = 0

D2 = D * D

for i in point:

    if (i[0]**2 + i[1]**2) <= D2:

        ct += 1

print(ct)

N , ĠD Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ point Ġ= Ġ[]ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġpoint .append (list (map (int , Ġinput (). split ())) )ĊĊĊĊ ct Ġ= Ġ 0 ĊĊ D 2 Ġ= ĠD Ġ* ĠD ĊĊ for Ġi Ġin Ġpoint :ĊĊ ĠĠĠ Ġif Ġ( i [ 0 ]** 2 Ġ+ Ġi [ 1 ]** 2 ) Ġ<= ĠD 2 :ĊĊ ĠĠĠĠĠĠĠ Ġct Ġ+= Ġ 1 ĊĊĊĊ print (ct )


Input:
from math import factorial

mod = 10**9 + 7

n = int(input())

ans = factorial(n) % mod

print(ans)

from Ġmath Ġimport Ġfactorial ĊĊĊĊ mod Ġ= Ġ 1 0 ** 9 Ġ+ Ġ 7 ĊĊ n Ġ= Ġint (input ())ĊĊ ĊĊ ans Ġ= Ġfactorial (n ) Ġ% Ġmod ĊĊ print (ans )


Input:
import heapq

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

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

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

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

def diff(l):

    m = max(l)

    return sorted(m - v for v in l)[1:]

s = sum(map(max, [a, b, c]))

sa, sb, sc = list(map(diff, [a, b, c]))

da, db, dc = [0], [0], [0]

q = [0]

while k > 0:

    while True:

        if len(sa) > 0 and (len(q) == 0 or q[0] > sa[0]):

            for v in [sa[0] + bb + cc for bb in db for cc in dc]:

                heapq.heappush(q, v)

            da.append(sa[0])

            sa = sa[1:]

        elif len(sb) > 0 and (len(q) == 0 or q[0] > sb[0]):

            for v in [sb[0] + aa + cc for aa in da for cc in dc]:

                heapq.heappush(q, v)

            db.append(sb[0])

            sb = sb[1:]

        elif len(sc) > 0 and (len(q) == 0 or q[0] > sc[0]):

            for v in [sc[0] + aa + bb for aa in da for bb in db]:

                heapq.heappush(q, v)

            dc.append(sc[0])

            sc = sc[1:]

        else:

            break

    v = heapq.heappop(q)

    print(s - v)

    k -= 1

import Ġheapq ĊĊĊĊ x , Ġy , Ġz , Ġk Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ a Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ b Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ c Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ def Ġdiff (l ):ĊĊ ĠĠĠ Ġm Ġ= Ġmax (l )ĊĊ ĠĠĠ Ġreturn Ġsorted (m Ġ- Ġv Ġfor Ġv Ġin Ġl )[ 1 :] ĊĊĊĊ s Ġ= Ġsum (map (max , Ġ[ a , Ġb , Ġc ]))ĊĊ sa , Ġsb , Ġsc Ġ= Ġlist (map (diff , Ġ[ a , Ġb , Ġc ]))ĊĊ da , Ġdb , Ġdc Ġ= Ġ[ 0 ], Ġ[ 0 ], Ġ[ 0 ]ĊĊ q Ġ= Ġ[ 0 ]ĊĊ while Ġk Ġ> Ġ 0 :ĊĊ ĠĠĠ Ġwhile ĠTrue :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġlen (sa ) Ġ> Ġ 0 Ġand Ġ( len (q ) Ġ== Ġ 0 Ġor Ġq [ 0 ] Ġ> Ġsa [ 0 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġv Ġin Ġ[ sa [ 0 ] Ġ+ Ġbb Ġ+ Ġcc Ġfor Ġbb Ġin Ġdb Ġfor Ġcc Ġin Ġdc ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġheapq .he app ush (q , Ġv )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġda .append (sa [ 0 ])ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġsa Ġ= Ġsa [ 1 :]ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġlen (sb ) Ġ> Ġ 0 Ġand Ġ( len (q ) Ġ== Ġ 0 Ġor Ġq [ 0 ] Ġ> Ġsb [ 0 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġv Ġin Ġ[ sb [ 0 ] Ġ+ Ġaa Ġ+ Ġcc Ġfor Ġaa Ġin Ġda Ġfor Ġcc Ġin Ġdc ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġheapq .he app ush (q , Ġv )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdb .append (sb [ 0 ])ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġsb Ġ= Ġsb [ 1 :]ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġlen (sc ) Ġ> Ġ 0 Ġand Ġ( len (q ) Ġ== Ġ 0 Ġor Ġq [ 0 ] Ġ> Ġsc [ 0 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġv Ġin Ġ[ sc [ 0 ] Ġ+ Ġaa Ġ+ Ġbb Ġfor Ġaa Ġin Ġda Ġfor Ġbb Ġin Ġdb ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġheapq .he app ush (q , Ġv )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdc .append (sc [ 0 ])ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġsc Ġ= Ġsc [ 1 :]ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġv Ġ= Ġheapq .he app op (q )ĊĊ ĠĠĠ Ġprint (s Ġ- Ġv )ĊĊ ĠĠĠ Ġk Ġ-= Ġ 1 Ċ


Input:
N = int(input())

A = [0]*N

X = []

Y = []

for i in range(N):

    A[i] = int(input())

    X.append([])

    Y.append([])

    for j in range(A[i]):

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

        X[i].append(x-1)

        Y[i].append(y)

ans = 0

for bit in range(1<<N):

    honest = 0

    ok = True

    for i in range(N):

        if bit&(1<<i):

            honest += 1

            for j in range(A[i]):

                if Y[i][j] == 0:

                    if bit&(1<<X[i][j]):

                        ok = False

                        break

                else:

                    if not bit&(1<<X[i][j]):

                        ok = False

                        break

            if not ok:

                break

    if ok:

        ans = max(ans, honest)

print(ans)

N Ġ= Ġint (input ())ĊĊ A Ġ= Ġ[ 0 ]* N ĊĊ X Ġ= Ġ[]ĊĊ Y Ġ= Ġ[]ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ ĠA [i ] Ġ= Ġint (input ())ĊĊ ĠĠĠ ĠX .append ([] )ĊĊ ĠĠĠ ĠY .append ([] )ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (A [i ]) :ĊĊ ĠĠĠĠĠĠĠ Ġx , Ġy Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠĠĠĠĠ ĠX [i ]. append (x - 1 )ĊĊ ĠĠĠĠĠĠĠ ĠY [i ]. append (y )ĊĊ ans Ġ= Ġ 0 ĊĊ for Ġbit Ġin Ġrange ( 1 << N ):ĊĊ ĠĠĠ Ġhonest Ġ= Ġ 0 ĊĊ ĠĠĠ Ġok Ġ= ĠTrue ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġbit &( 1 << i ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġhonest Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange (A [i ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif ĠY [i ][ j ] Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġbit &( 1 << X [i ][ j ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġok Ġ= ĠFalse ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġnot Ġbit &( 1 << X [i ][ j ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġok Ġ= ĠFalse ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġnot Ġok :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġif Ġok :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ= Ġmax (ans , Ġhonest )ĊĊ print (ans )


Input:
from collections import Counter

import sys

input = sys.stdin.readline

def solve():

    N = int(input())

    Sss = [input().rstrip() for _ in range(N)]

    cnt = Counter(Sss)

    #print('cnt:', cnt)

    maxNum = max(cnt.values())

    #print('maxNum:', maxNum)

    anss = []

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

        if value == maxNum:

            anss.append(key)

    #print('anss:', anss)

    anss.sort()

    print(('\n'.join(anss)))

solve()

from Ġcollections Ġimport ĠCounter ĊĊ import Ġsys ĊĊ input Ġ= Ġsys .stdin .readline ĊĊĊĊ def Ġsolve ():ĊĊ ĠĠĠ ĠN Ġ= Ġint (input ())ĊĊ ĠĠĠ ĠS ss Ġ= Ġ[ input (). rstrip () Ġfor Ġ_ Ġin Ġrange (N )] ĊĊĊĊ ĠĠĠ Ġcnt Ġ= ĠCounter (S ss )ĊĊ ĠĠĠ Ġ# print (' cnt :', Ġcnt )ĊĊĊĊ ĠĠĠ Ġmax Num Ġ= Ġmax (cnt .values ())ĊĊ ĠĠĠ Ġ# print (' max Num :', Ġmax Num )ĊĊĊĊ ĠĠĠ Ġan ss Ġ= Ġ[]ĊĊ ĠĠĠ Ġfor Ġkey , Ġvalue Ġin Ġlist (cnt .items ()) :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġvalue Ġ== Ġmax Num :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġan ss .append (key )ĊĊ ĠĠĠ Ġ# print (' ans s :', Ġan ss )ĊĊĊĊ ĠĠĠ Ġan ss .sort ()ĊĊĊĊ ĠĠĠ Ġprint ( ('\ n '. join (ans s )))ĊĊ ĊĊĊĊ solve ()Ċ


Input:
"""Minimum cost Sort."""

def min_cost_sort(A):

    """Sort list A in ascending order.

    And return the switching cost in sorting.

    """

    B = list(A)

    B.sort()

    cost = 0

    min_w = B[0]

    for i, b in enumerate(B):

        tmp_cost = 0

        bi = A.index(b)

        n = 1

        while bi != i:

            n += 1

            st = B[bi]

            si = A.index(st)

            tmp_cost += b + st

            A[bi], A[si] = st, b

            bi = si

        dec = (n - 1) * (b - min_w)

        inc = 2 * (min_w + b)

        if dec < inc:

            cost += tmp_cost

        else:

            cost += tmp_cost - dec + inc

    return cost

n = input()

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

ans = min_cost_sort(A)

print(ans)

""" Minimum Ġcost ĠSort .""" ĊĊĊĊ def Ġmin _cost _sort (A ):ĊĊ ĠĠĠ Ġ""" Sort Ġlist ĠA Ġin Ġascending Ġorder .ĊĊ ĠĊĊ ĠĠĠ ĠAnd Ġreturn Ġthe Ġswitching Ġcost Ġin Ġsorting .ĊĊ ĠĠĠ Ġ"""ĊĊ ĠĠĠ ĠB Ġ= Ġlist (A )ĊĊ ĠĠĠ ĠB .sort ()ĊĊ ĠĠĠ Ġcost Ġ= Ġ 0 ĊĊ ĠĠĠ Ġmin _w Ġ= ĠB [ 0 ]ĊĊ ĠĠĠ Ġfor Ġi , Ġb Ġin Ġenumerate (B ):ĊĊ ĠĠĠĠĠĠĠ Ġtmp _cost Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġbi Ġ= ĠA .index (b )ĊĊ ĠĠĠĠĠĠĠ Ġn Ġ= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġbi Ġ!= Ġi :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġn Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġst Ġ= ĠB [ bi ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġsi Ġ= ĠA .index (st )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġtmp _cost Ġ+= Ġb Ġ+ Ġst ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠA [ bi ], ĠA [ si ] Ġ= Ġst , Ġb ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbi Ġ= Ġsi ĊĊ ĠĠĠĠĠĠĠ Ġdec Ġ= Ġ( n Ġ- Ġ 1 ) Ġ* Ġ( b Ġ- Ġmin _w )ĊĊ ĠĠĠĠĠĠĠ Ġinc Ġ= Ġ 2 Ġ* Ġ( min _w Ġ+ Ġb )ĊĊ ĠĠĠĠĠĠĠ Ġif Ġdec Ġ< Ġinc :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcost Ġ+= Ġtmp _cost ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcost Ġ+= Ġtmp _cost Ġ- Ġdec Ġ+ Ġinc ĊĊ ĠĠĠ Ġreturn Ġcost ĊĊĊĊĊĊ n Ġ= Ġinput ()ĊĊĊĊ A Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ ans Ġ= Ġmin _cost _sort (A )ĊĊĊĊ print (ans )


Input:
from functools import lru_cache

import sys

sys.setrecursionlimit(2000)

s = int(input())

mod = 10 ** 9 + 7

@lru_cache(maxsize=None)

def dfs(n):

    if n <= 2:

        return 0

    elif 3<=n<=5:

        return 1

    else:

        count = 1

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

            count += dfs(n - i)

            count %= mod

        return count % mod

ans = dfs(s)

print(ans)

from Ġfunctools Ġimport Ġl ru _cache ĊĊ import Ġsys ĊĊĊĊ sys .set rec ursion limit ( 2 0 0 0 )ĊĊĊĊ s Ġ= Ġint (input ())ĊĊ mod Ġ= Ġ 1 0 Ġ** Ġ 9 Ġ+ Ġ 7 ĊĊĊĊĊĊ @ l ru _cache (max size =None )ĊĊ def Ġdfs (n ):ĊĊ ĠĠĠ Ġif Ġn Ġ<= Ġ 2 :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ 0 ĊĊ ĠĠĠ Ġelif Ġ 3 <= n <= 5 :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ 1 ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġcount Ġ= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġrange ( 3 , Ġn Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcount Ġ+= Ġdfs (n Ġ- Ġi )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcount Ġ%= Ġmod ĊĊĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġcount Ġ% Ġmod ĊĊĊĊĊĊ ans Ġ= Ġdfs (s )ĊĊ print (ans )Ċ


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

num = 0

q = []

for i in range(n):

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

    q.append((a,b))

q.sort()

for i in range(n):

    a, b = q[i][0], q[i][1]

    num += b

    if num >= k:

        print(a)

        exit()

n ,k Ġ= Ġlist (map (int ,input (). split ()))ĊĊ num Ġ= Ġ 0 ĊĊ q Ġ= Ġ[]ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġa ,b Ġ= Ġlist (map (int ,input (). split ()))ĊĊ ĠĠĠ Ġq .append (( a ,b ))ĊĊ q .sort ()ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġa , Ġb Ġ= Ġq [i ][ 0 ], Ġq [i ][ 1 ]ĊĊ ĠĠĠ Ġnum Ġ+= Ġb ĊĊ ĠĠĠ Ġif Ġnum Ġ>= Ġk :ĊĊ ĠĠĠĠĠĠĠ Ġprint (a )ĊĊ ĠĠĠĠĠĠĠ Ġexit ()ĊĊĊ


Input:
import sys

input = sys.stdin.readline

from collections import *

def dfs(x, y):

    if x==0 and y==0:

        t[x][y] = False

        return False

    if x>=1:

        t[x][y] |= not dfs(x-1, y)

    if y>=1:

        t[x][y] |= not dfs(x, y-1)

    if min(x, y)>=1:

        t[x][y] |= not dfs(x-1, y-1)

    return t[x][y]

t = [[False]*7 for _ in range(7)]

for i in range(7):

    for j in range(7):

        dfs(i, j)

"""

for ti in t:

    print(*ti)

"""

N = int(input())

flag = True

for _ in range(N):

    a = int(input())

    if a%2==1:

        flag = False

if flag:

    print('second')

else:

    print('first')

import Ġsys ĊĊ input Ġ= Ġsys .stdin .readline ĊĊ from Ġcollections Ġimport Ġ* ĊĊĊĊ def Ġdfs (x , Ġy ):ĊĊ ĠĠĠ Ġif Ġx == 0 Ġand Ġy == 0 :ĊĊ ĠĠĠĠĠĠĠ Ġt [x ][ y ] Ġ= ĠFalse ĊĊ ĠĠĠĠĠĠĠ Ġreturn ĠFalse ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġif Ġx >= 1 :ĊĊ ĠĠĠĠĠĠĠ Ġt [x ][ y ] Ġ|= Ġnot Ġdfs (x - 1 , Ġy )ĊĊ ĠĠĠĠĠĠĠĠĊĊ ĠĠĠ Ġif Ġy >= 1 :ĊĊ ĠĠĠĠĠĠĠ Ġt [x ][ y ] Ġ|= Ġnot Ġdfs (x , Ġy - 1 )ĊĊ ĠĠĠĠĠĠĠĠĊĊ ĠĠĠ Ġif Ġmin (x , Ġy )>= 1 :ĊĊ ĠĠĠĠĠĠĠ Ġt [x ][ y ] Ġ|= Ġnot Ġdfs (x - 1 , Ġy - 1 )ĊĊ ĠĠĠĊĊ ĠĠĠ Ġreturn Ġt [x ][ y ]ĊĊ ĠĠĠĠĊĊ t Ġ= Ġ[[ False ]* 7 Ġfor Ġ_ Ġin Ġrange ( 7 )] ĊĊĊĊ for Ġi Ġin Ġrange ( 7 ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange ( 7 ):ĊĊ ĠĠĠĠĠĠĠ Ġdfs (i , Ġj )ĊĊĊĊ """ĊĊ for Ġti Ġin Ġt :ĊĊ ĠĠĠ Ġprint (* ti )ĊĊ """ ĊĊĊĊ N Ġ= Ġint (input ())ĊĊ flag Ġ= ĠTrue ĊĊĊĊ for Ġ_ Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġa Ġ= Ġint (input ())ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġif Ġa % 2 == 1 :ĊĊ ĠĠĠĠĠĠĠ Ġflag Ġ= ĠFalse ĊĊ ĠĠĠĠĠĠĠĠĊĊ if Ġflag :ĊĊ ĠĠĠ Ġprint (' second ')ĊĊ else :ĊĊ ĠĠĠ Ġprint (' first ')


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

cnt=0

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

    n=list(str(i))

    if n==list(reversed(n)):

        cnt+=1

print(cnt)

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


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

count = 0

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

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

        count += 1

print(count)

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


Input:
import math

N = int(input())

p = math.factorial(N)

print((p % 1000000007))

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


Input:
import sys

input = sys.stdin.readline

s = input().rstrip()

k = int(input())

def check_count(s):

    cnt_list = [1]

    cnt = 1

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

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

            cnt_list[-1] += 1

        else:

            cnt_list.append(1)

    return cnt_list

def calc_ans(cnt_list, k):

    _ans = 0

    for c in cnt_list:

        _ans += c//2

    return(_ans * k)

if len(s)==1:

    ans = k//2

else:

    cnt_list = check_count(s)

    if len(cnt_list)==1:

        ans = (len(s)*k)//2

    else:

        ans = calc_ans(cnt_list, k)

        if s[0]==s[-1]:

            if cnt_list[0]%2==1 and cnt_list[-1]%2==1:

                ans += k - 1

print(ans)

import Ġsys ĊĊ input Ġ= Ġsys .stdin .readline ĊĊ ĠĊĊ s Ġ= Ġinput (). rstrip ()ĊĊ k Ġ= Ġint (input ())ĊĊ ĠĠĠĠĊĊ def Ġcheck _count (s ):ĊĊ ĠĠĠ Ġcnt _list Ġ= Ġ[ 1 ]ĊĊ ĠĠĠ Ġcnt Ġ= Ġ 1 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 , Ġlen (s )) :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġs [i - 1 ] Ġ== Ġs [i ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt _list [- 1 ] Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt _list .append ( 1 )ĊĊ ĠĠĠ Ġreturn Ġcnt _list ĊĊĊĊ def Ġcalc _ans (cnt _list , Ġk ):ĊĊ ĠĠĠ Ġ_ ans Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġc Ġin Ġcnt _list :ĊĊ ĠĠĠĠĠĠĠ Ġ_ ans Ġ+= Ġc // 2 ĊĊ ĠĠĠ Ġreturn (_ ans Ġ* Ġk )ĊĊĊĊ if Ġlen (s )== 1 :ĊĊ ĠĠĠ Ġans Ġ= Ġk // 2 ĊĊ else :ĊĊ ĠĠĠ Ġcnt _list Ġ= Ġcheck _count (s )ĊĊ ĠĠĠ Ġif Ġlen (cnt _list )== 1 :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ= Ġ( len (s )* k )// 2 ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ= Ġcalc _ans (cnt _list , Ġk )ĊĊ ĠĠĠĠĠĠĠ Ġif Ġs [ 0 ]== s [- 1 ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġcnt _list [ 0 ]% 2 == 1 Ġand Ġcnt _list [- 1 ]% 2 == 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ+= Ġk Ġ- Ġ 1 ĊĊĊĊ print (ans )


Input:
N = int(input())

def dist(i, j):

    return i + j - 2

min = 10 ** 24

i = 1

while (i ** 2) <= N:

    if 0 == N % i:

        j = N // i

        d = dist(i, j)

        if min > d:

            min = d

    i += 1

print(d)

N Ġ= Ġint (input ())ĊĊ ĊĊĊĊ def Ġdist (i , Ġj ):ĊĊ ĠĠĠ Ġreturn Ġi Ġ+ Ġj Ġ- Ġ 2 ĊĊĊĊĊĊ min Ġ= Ġ 1 0 Ġ** Ġ 2 4 ĊĊ i Ġ= Ġ 1 ĊĊ while Ġ( i Ġ** Ġ 2 ) Ġ<= ĠN :ĊĊ ĠĠĠ Ġif Ġ 0 Ġ== ĠN Ġ% Ġi :ĊĊ ĠĠĠĠĠĠĠ Ġj Ġ= ĠN Ġ// Ġi ĊĊ ĠĠĠĠĠĠĠ Ġd Ġ= Ġdist (i , Ġj )ĊĊ ĠĠĠĠĠĠĠ Ġif Ġmin Ġ> Ġd :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġmin Ġ= Ġd ĊĊ ĠĠĠ Ġi Ġ+= Ġ 1 ĊĊ print (d )Ċ


Input:
n = int(input())

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

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


Input:
import sys

readline = sys.stdin.readline

sys.setrecursionlimit(10**8)

mod = 10**9+7

#mod = 998244353

INF = 10**18

eps = 10**-7

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

def comb(n, r, mod):

    r = min(r, n-r)

    mol = 1

    deno = 1

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

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

        deno = deno * i % mod

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

    return ret

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

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

def f2(x,a):

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

ans = 0

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

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

        ans += f1(x,y,n,m)+f1(1,1,x,y)+f1(1,y,x,m)+f1(x,1,n,y)

        ans -= f2(x,n) + f2(1,x) + f2(1,y) + f2(y,m)

        ans %= mod

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

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

print(ans)

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


Input:
import sys

sys.setrecursionlimit(10**7)

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

n, m = lmi()

l = [0] * (n+1)

l[0] = 1

a = 0

if m != 0:

    a = int(input())

k = 1

for i in range(n+1):

    if i != a:

        if i == 1:

            l[i] = 1

        elif i >= 2:

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

            l[i] %= 1000000007

    else:

        k += 1

        if k <= m:

            a = int(input())

#print(l)

print((l[n] % 1000000007))

import Ġsys ĊĊ sys .set rec ursion limit ( 1 0 ** 7 )ĊĊ def Ġl mi (): Ġreturn Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ n , Ġm Ġ= Ġl mi ()ĊĊĊĊ l Ġ= Ġ[ 0 ] Ġ* Ġ( n + 1 )ĊĊ l [ 0 ] Ġ= Ġ 1 ĊĊĊĊ a Ġ= Ġ 0 ĊĊ if Ġm Ġ!= Ġ 0 :ĊĊ ĠĠĠ Ġa Ġ= Ġint (input ())ĊĊ k Ġ= Ġ 1 ĊĊ for Ġi Ġin Ġrange (n + 1 ): ĊĊĊĊ ĠĠĠ Ġif Ġi Ġ!= Ġa :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġi Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġl [i ] Ġ= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġi Ġ>= Ġ 2 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġl [i ] Ġ= Ġl [i - 1 ] Ġ+ Ġl [i - 2 ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġl [i ] Ġ%= Ġ 1 0 0 0 0 0 0 0 0 7 ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġk Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġif Ġk Ġ<= Ġm :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġa Ġ= Ġint (input ())ĊĊ ĊĊĊĊĊĊ #print (l )ĊĊ print (( l [n ] Ġ% Ġ 1 0 0 0 0 0 0 0 0 7 ))Ċ


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

MOD = 10**9+7

dp = [0]*(N+1)

dp[0]=1

A = [int(input()) for i in range(M)]

ban = [1]*(N+1)

for a in A:

    ban[a]=0

for i in range(N):

    if i-1>=0:

        dp[i+1]=dp[i]*ban[i]+dp[i-1]*ban[i-1]

    else:

        dp[i+1]=dp[i]*ban[i]

    dp[i+1] %= MOD

print((dp[N]))

N ,M Ġ= Ġlist (map (int ,input (). split ()))ĊĊ MOD Ġ= Ġ 1 0 ** 9 + 7 ĊĊ dp Ġ= Ġ[ 0 ]*( N + 1 )ĊĊ dp [ 0 ]= 1 ĊĊ A Ġ= Ġ[ int (input ()) Ġfor Ġi Ġin Ġrange (M )]ĊĊ ban Ġ= Ġ[ 1 ]*( N + 1 )ĊĊ for Ġa Ġin ĠA :ĊĊ ĠĠĠ Ġban [a ]= 0 ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġif Ġi - 1 >= 0 :ĊĊ ĠĠĠĠĠĠĠ Ġdp [i + 1 ]= dp [i ]* ban [i ]+ dp [i - 1 ]* ban [i - 1 ]ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġdp [i + 1 ]= dp [i ]* ban [i ]ĊĊ ĠĠĠ Ġdp [i + 1 ] Ġ%= ĠMOD ĠĊĊ print (( dp [N ]))


Input:
def main():

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

    M = max(X, Y)

    k = 0

    ans = A * X + B * Y

    while True:

        ans = min(

            ans,

            AB * k * 2 + max(0, X - k) * A + max(0, Y - k) * B

        )

        if k >= M: break

        k += 1

    print(ans)

if __name__ == '__main__':

    main()

def Ġmain ():ĊĊ ĠĠĠ ĠA , ĠB , ĠAB , ĠX , ĠY Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ ĠM Ġ= Ġmax (X , ĠY )ĊĊĊĊ ĠĠĠ Ġk Ġ= Ġ 0 ĊĊ ĠĠĠ Ġans Ġ= ĠA Ġ* ĠX Ġ+ ĠB Ġ* ĠY ĊĊ ĠĠĠ Ġwhile ĠTrue :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ= Ġmin (ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans ,ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠAB Ġ* Ġk Ġ* Ġ 2 Ġ+ Ġmax ( 0 , ĠX Ġ- Ġk ) Ġ* ĠA Ġ+ Ġmax ( 0 , ĠY Ġ- Ġk ) Ġ* ĠB ĊĊ ĠĠĠĠĠĠĠ Ġ)ĊĊ ĊĊ ĠĠĠĠĠĠĠ Ġif Ġk Ġ>= ĠM : Ġbreak ĊĊ ĠĠĠĠĠĠĠ Ġk Ġ+= Ġ 1 ĊĊĊĊ ĠĠĠ Ġprint (ans )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()Ċ