Harryxun/sft_time huggingface dataset:
### BUGGY CODE ###

n = int(input())
a = list(map(int, input().split()))
b = [0]*n
bon = []
for i in range(n):
  ri = n - i - 1
  if sum(b[ri::ri+1]) % 2 != a[ri]:
    b[ri] = 1
    bon.append(ri+1)
for i in range(n):
  if sum(b[ri::ri+1]) % 2 != a[ri]:
    print(-1)
    exit()
print(len(bon))
print(*bon)

### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))
b = [0]*n
bon = []
for i in range(n):
  ri = n - i - 1
  if sum(b[ri::ri+1]) % 2 != a[ri]:
    b[ri] = 1
    bon.append(ri+1)
print(len(bon))
print(*bon)
### BUGGY CODE ###

class RollingHash:
    def __init__(self, s: str, base: int=1007, mod: int=10**9+7):
        self.s = s
        self.n = len(s)
        self.base = base
        self.mod = mod

        # preprocess
        self.hash_cum = [0] * (self.n + 1) # hash_cum[i] = (hash of s[:i])
        self.base_pow = [1] * (self.n + 1) # base_pow[i] = base ** i
        for i in range(self.n):
            self.hash_cum[i+1] = (self.hash_cum[i] * base + ord(s[i])) % mod
            self.base_pow[i+1] = (self.base_pow[i] * base) % mod

    def get_hash(self, l: int, r: int) -> int:
        hash_val = self.hash_cum[r] - self.hash_cum[l] * self.base_pow[r-l] % self.mod
        if hash_val < 0:
            hash_val += self.mod
        return hash_val


class RollingHashMulti:
    def __init__(self, s: str, base_list: list=[1007, 2009], mod_list: list=[10**9+7, 10**9+9]):
        self.n = len(base_list)
        self.base_list = base_list
        self.rh_list = [RollingHash(s, base_list[i], mod_list[i]) for i in range(self.n)]

    def get_hash(self, l: int, r: int) -> tuple:
        return tuple( self.rh_list[i].get_hash(l, r) for i in range(self.n) )




n = int(input())
s = input()

rh = RollingHashMulti(s)

def check(x):
    for i in range(n-2*x+1):
        for j in range(i+x, n-x+1):
            if rh.get_hash(i, i+x) == rh.get_hash(j, j+x):
                return True
    return False


lb = 0
ub = n // 2 + 1
while ub - lb > 1:
    mid = (ub + lb) // 2
    if check(mid):
        lb = mid
    else:
        ub = mid

print(lb)


### FIXED CODE ###

n = int(input())
s = input()

n += 1
s += "#"

ans = 0
for i in range(1, n):
    cnt = 0
    for j in range(n-i):
        if s[i+j] == s[j]:
            cnt += 1
        else:
            ans = max(ans, min(cnt, i))
            cnt = 0

print(ans)
### BUGGY CODE ###

# indeednow_A_b
import sys
from sys import stdin
N, M = [int(x) for x in stdin.readline().rstrip().split()]
L = [0 for i in range(M)]
R = [0 for i in range(M)]
for i in range(M):
    L[i], R[i] = [int(x) for x in stdin.readline().rstrip().split()]
# print(L, R)
ans = set()

for k in range(M):
    temp = set()
    for l in range(L[k], R[k]+1):
        temp.add(l)
    if len(ans) != 0:
        ans = temp & ans
    else:
        ans = temp
print(len(ans))


### FIXED CODE ###

# indeednow_A_b
import sys
from sys import stdin
N, M = [int(x) for x in stdin.readline().rstrip().split()]
L = [0 for i in range(M)]
R = [0 for i in range(M)]
for i in range(M):
    L[i], R[i] = [int(x) for x in stdin.readline().rstrip().split()]
# print(L, R)
ans = set()
ans1 = 0
ans2 = 10**6
for k in range(M):
    if ans2 < L[k]:
        print("0")
        sys.exit()
    if ans1 < L[k]:
        ans1 = L[k]
    if ans2 > R[k]:
        ans2 = R[k]

    # temp = set()
    # for l in range(L[k], R[k]+1):
    #     temp.add(l)
    # if len(ans) != 0:
    #     ans = temp & ans
    # else:
    #     ans = temp
print(ans2+1-ans1)
### BUGGY CODE ###

H, N = map(int, input().split())
M = [tuple(map(int, input().split())) for _ in range(N)]
dp = [float('inf')] * (H + 1)
dp[0] = 0
for h in range(H):
    if dp[h] == float('inf'):
        continue
    for a, b in M:
        idx = min(H, h + a)
        dp[idx] = min(dp[idx], dp[h] + b)
print(dp[H])


### FIXED CODE ###

H, N = map(int, input().split())
M = [tuple(map(int, input().split())) for _ in range(N)]
dp = [float('inf')] * (H + 1)
dp[0] = 0
for h in range(H):
    if dp[h] == float('inf'):
        continue
    for a, b in M:
        idx = min(H, h + a)
        dp[idx] = min(dp[idx], dp[h] + b)
print(dp[H])
### BUGGY CODE ###

[n,q] = map(int,input().split())

t = [ 0 for _ in range(n) ]
for _ in range(q):
    [a,v] = map(int,input().split())
    t[a-1] += v

    p = t.index(max(t))

    print("{} {}".format(p+1,t[p]))

### FIXED CODE ###

[n,q] = map(int,input().split())

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

max_idx = 0
max_val = 0

for _ in range(q):
    [a,v] = map(int,input().split())
    t[a-1] += v

    if max_idx == a-1:
        if v > 0:
            max_val = t[a-1]
        else:
            max_val = max(t)
            max_idx = t.index(max_val)
    elif t[a-1] > max_val:
        max_val = t[a-1]
        max_idx = a-1
    elif t[a-1] == max_val:
        if a-1 < max_idx:
            max_val = t[a-1]
            max_idx = a-1

    print("{} {}".format(max_idx+1,max_val))
### BUGGY CODE ###

M=10**9+7;F=[pow(X,M-2,M)for X in range(8**6)];H,W,A,B=map(int,input().split());Z=C=1
for I in range(H-1):Z=C=C*(W+H-B-2-I)*F[I+1]%M
for I in range(1,H-A):C=C*(B-1+I)*F[I]*(H-I)*F[W+H-B-1-I]%M;Z=(Z+C)%M
print(Z)

### FIXED CODE ###

F=lambda X:pow(X,M-2,M);M=10**9+7;H,W,A,B=map(int,input().split());Z=C=1
for I in range(min(W-1-B,H-1)):Z=C=C*(W+H-B-2-I)*F(I+1)%M
for I in range(1,H-A):C=C*(B-1+I)*F(I)*(H-I)*F(W+H-B-1-I)%M;Z=(Z+C)%M
print(Z)
### BUGGY CODE ###

L,R=map(int,input().split())
ans=2019
if L-R>=2018:print(0)
else:
    for i in range(L,R):
        for j in range(i+1,R+1):
            a = (i*j)%2019
            if a < ans:ans=a
print(ans)



### FIXED CODE ###

L,R=map(int,input().split())
ans=2019
if R-L>=2018:ans=0
else:
    for i in range(L,R):
        for j in range(i+1,R+1):
            a = (i*j)%2019
            if a < ans:ans=a
print(ans)
### BUGGY CODE ###

k = int(input())
mo = 0
for i in range(1, k + 1):
    mo = mo * 10 + 7
    l = mo % k
    if l == 0:
        print(i)
        break
else:
    print(-1)

### FIXED CODE ###

k = int(input())
mo = 7
mo = mo % k
for i in range(1 , k + 1):
  if mo == 0:
    print(i)
    break
  if mo != 0:
    mo = (mo * 10 + 7) % k
else:
  print(-1)
### BUGGY CODE ###

from sys import stdin, setrecursionlimit
from heapq import heapify, heappop, heappush


def main():
    input = stdin.buffer.readline
    n, m = map(int, input().split())
    a = list(map(int, input().split()))
    heapify(a)

    for _ in range(m):
        b, c = map(int, input().split())
        for _ in range(b):
            ai = heappop(a)
            heappush(a, max(c, ai))

    print(sum(a))


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()


### FIXED CODE ###

from sys import stdin, setrecursionlimit
from heapq import heapify, heappop, heappush


def main():
    input = stdin.buffer.readline
    n, m = 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])
    heapify(a)

    for i in range(m):
        b, c = bc[i]
        for _ in range(b):
            ai = heappop(a)
            if ai < c:
                heappush(a, c)
            else:
                heappush(a, ai)
                break

    print(sum(a))


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()
### BUGGY CODE ###

n = int(input())
numbers = [int(i) for i in input().split()]
count = 0
while True:
  for i in range(n):
    if numbers[i] % 2 != 0:
      print(count)
      break
    else:
      numbers[i] = int(numbers[i]) / 2
  count += 1

### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))
ans = 0
while True:
    for i in range(n):
        if a[i] % 2 == 0:
            a[i] = a[i] // 2
        else:
            print(ans)
            exit()
    ans += 1
### BUGGY CODE ###

import itertools
import sys


if __name__ == '__main__':
    D, G = map(int, input().split())
    # pc_list = [list(map(int,input().split())) for i in range(D)]

    p = ['-1'] * D
    c = ['-1'] * D

    for i in range(D):
        p[i], c[i] = map(int, input().split())

    if D == 1:
        my_list = list(itertools.product(range(p[0]+1)))
    elif D == 2:
        my_list = list(itertools.product(range(p[0]+1),range(p[1]+1)))
    elif D == 3:
        my_list = list(itertools.product(range(p[0]+1),range(p[1]+1), range(p[2]+1)))
    elif D == 4:
        my_list = list(itertools.product(range(p[0]+1),range(p[1]+1), range(p[2]+1), range(p[3]+1)))
    elif D == 5:
        my_list = list(itertools.product(range(p[0]+1),range(p[1]+1), range(p[2]+1), range(p[3]+1), range(p[4]+1)))
    elif D == 6:
        my_list = list(itertools.product(range(p[0]+1),range(p[1]+1), range(p[2]+1), range(p[3]+1), range(p[4]+1), range(p[5]+1)))
    elif D == 7:
        my_list = list(itertools.product(range(p[0]+1),range(p[1]+1), range(p[2]+1), range(p[3]+1), range(p[4]+1), range(p[5]+1), range(p[6]+1)))
    elif D == 8:
        my_list = list(itertools.product(range(p[0]+1),range(p[1]+1), range(p[2]+1), range(p[3]+1), range(p[4]+1), range(p[5]+1), range(p[6]+1), range(p[7]+1)))
    elif D == 9:
        my_list = list(itertools.product(range(p[0]+1),range(p[1]+1), range(p[2]+1), range(p[3]+1), range(p[4]+1), range(p[5]+1), range(p[6]+1), range(p[7]+1), range(p[8]+1)))
    elif D == 10:
        my_list = list(itertools.product(range(p[0]+1),range(p[1]+1), range(p[2]+1), range(p[3]+1), range(p[4]+1), range(p[5]+1), range(p[6]+1), range(p[7]+1), range(p[8]+1), range(p[9]+1)))

    min_count = sys.maxsize
    for e in my_list:
        e_list = list(e)
        score = 0
        for i in range(len(e_list)):
            score += (i+1)*100*e_list[i]
            if e[i] == p[i]:
                score += c[i]
        count = sum(e_list)
        if score >= G and min_count > count:
            min_count = count
    print(min_count)


### FIXED CODE ###

import sys


if __name__ == '__main__':
    D, G = map(int, input().split())
    p = ['-1'] * D
    c = ['-1'] * D
    for i in range(D):
        p[i], c[i] = map(int, input().split())

    answer = sys.maxsize
    for i in range(pow(2, D)):
        bonus_flags = format(i, "b").zfill(D)

        score = 0
        count = 0
        remain = []
        for index, bonus_flag in enumerate(bonus_flags):
            if bonus_flag == '1':
                score += (index + 1) * 100 * p[index] + c[index]
                count += p[index]
            else:
                remain.append(index)
        if score < G:
            R = G - score
            j = remain[-1]

            if (p[j] - 1) * (j+1) * 100 < R:
                continue
            count += -(-R//(100*(j+1)))
        answer = min(answer, count)

    print(answer)
### BUGGY CODE ###

import numpy as np 
N = int(input())
S = np.array(list(input()))

R = np.where(S == 'R')[0]
G = np.where(S == 'G')[0]
B = np.where(S == 'B')[0]
ans = 0
for r in R:
    for g in G:
        for b in B:
            mi, mid, ma = sorted([r, g, b])
            if mid - mi != ma - mid:
                ans +=1
print(ans)

### FIXED CODE ###

N = int(input())
S = input()
ans = S.count("R") * S.count("G") * S.count("B")
for i in range(N):
    for j in range(i + 1, N):
        k = j - i + j
        if k < N:
            if {S[i], S[j], S[k]} == {"R", "G", "B"}:
                ans -= 1
print(ans)
### BUGGY CODE ###

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

def getValue(initial, diff):
  initial = abs(initial - diff)
  return initial

tempValue = n

if k > 1:
  while(tempValue > getValue(tempValue, k)):
    tempValue = getValue(tempValue, k)
else:
  tempValue = 0

print(tempValue)

### FIXED CODE ###

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

mod = n % k
candidate = abs(mod - k)

print(min(mod, candidate))
### BUGGY CODE ###

S = input()

ans = 0
for i in range(len(S)):
    for j in range(i+1, len(S)):
        if int(S[i:j+1]) % 2019 == 0:
            ans += 1

print(ans)

### FIXED CODE ###

from collections import Counter

S = input()
N = len(S)

dp = [0] * N
dp[N-1] = int(S[N-1])
times = 10
for i in reversed(range(1, N)):
    dp[i-1] = (dp[i] + times * int(S[i-1])) % 2019
    times *= 10
    times %= 2019

T = Counter(dp)
ans = T[0]
for t in T.values():
    ans += t*(t-1)//2

print(ans)
### BUGGY CODE ###

N=input()
L=len(N)
ans=[[0 for e in range(2)] for f in range(L)]
k=int(N[L-1])
ans[0][0]=k
ans[0][1]=10-k
if L>1:
 for i in range(1,L):
  k=int(N[L-1-i])
  ans[i][0]=min(ans[i-1][0]+k,ans[i-1][1]+k+1)
  ans[i][1]=min(ans[i-1][0]+10-k,ans[i-1][1]+10-k-1)
print(min(ans[L-1][0],ans[L-1][1]+1))


### FIXED CODE ###

N=input()
L=len(N)
ans=[[0 for e in range(2)] for f in range(L)]
k=int(N[L-1])
ans[0][0]=k
ans[0][1]=10-k
if L>1:
 for i in range(1,L):
  k=int(N[L-1-i])
  ans[i][0]=min(ans[i-1][0]+k,ans[i-1][1]+k+1)
  ans[i][1]=min(ans[i-1][0]+10-k,ans[i-1][1]+10-k-1)
print(min(ans[L-1][0],ans[L-1][1]+1))
### BUGGY CODE ###

import sys
sys.setrecursionlimit(10 ** 6)

N = int(input())
A = list(map(int, input().split()))
MOD = 10**9+ 7

ans = 0
for i in range(61):
  n = sum([int(bin(a>>i)[-1]) for a in A])
  ans += (n * (N - n) * (2 ** i) % MOD)
print(ans%MOD)

### FIXED CODE ###

import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline

N = int(input())
A = list(map(int, input().split()))
MOD = 10**9+ 7

ans = 0
two = 1
for i in range(61):
  n = len([ a for a in A if (a >> i) & 1 ])
  ans += (n * (N - n) * two % MOD)
  two *= 2 
print(ans%MOD)
### BUGGY CODE ###

mod=10**9+7
n=int(input())
T=[int(i) for i in input().split()]
A=[int(i) for i in input().split()]
Tres=[0]*n
Ares=[0]*n
Tres[0]=(0,T[0])
Ares[n-1]=(0,A[n-1])
for i in range(1,n):
  if T[i]!=Tres[i-1][1]:
    Tres[i]=(0,T[i])
  else:
    Tres[i]=(1,T[i])
  if A[n-i-1]!=Ares[n-i][1]:
    Ares[n-i-1]=(0,A[n-i-1])
  else:
    Ares[n-i-1]=(1,A[n-i-1])
if Tres[0]<=Ares[0]:
  ans=1
else:
  ans=0
for i in range(1,n):
  ta,tb=Tres[i]
  aa,ab=Ares[i]  
  if ta==aa==1:
    ans*=min(tb,ab)%mod
  elif ta==0 and aa==1 and tb>ab:
    ans=0
  elif ta==1 and aa==0 and tb<ab:
    ans=0
  elif ta==0 and aa==0 and tb!=ab:
    ans=0
print(ans%mod)

### FIXED CODE ###

mod=10**9+7
n=int(input())
T=[int(i) for i in input().split()]
A=[int(i) for i in input().split()]
Tres=[0]*n
Ares=[0]*n
Tres[0]=(0,T[0])
Ares[n-1]=(0,A[n-1])
for i in range(1,n):
  if T[i]>Tres[i-1][1]:
    Tres[i]=(0,T[i])
  else:
    Tres[i]=(1,T[i])
  if A[n-i-1]>Ares[n-i][1]:
    Ares[n-i-1]=(0,A[n-i-1])
  else:
    Ares[n-i-1]=(1,A[n-i-1])
if Tres[0]<=Ares[0]:
  ans=1
else:
  ans=0
for i in range(1,n):
  ta,tb=Tres[i]
  aa,ab=Ares[i]  
  if ta==aa==1:
    ans=ans*min(tb,ab)%mod
  elif ta==0 and aa==1 and tb>ab:
    ans=0
  elif ta==1 and aa==0 and tb<ab:
    ans=0
  elif ta==0 and aa==0 and tb!=ab:
    ans=0
print(ans%mod)
### BUGGY CODE ###

#Coding:Utf-8
import sys
input=sys.stdin.readline

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

for i in range(N):
    print((A.index(i+1))+1,end=" ")
print("")


### FIXED CODE ###

#Coding:Utf-8
import sys
input=sys.stdin.readline

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

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

for l in range(N):
    print(ans[l],end=" ")

print("")
### BUGGY CODE ###

a, b, c, d = map(int, input().split())
lst = []
cnt = 0
for i in range(a, b+1):
    if i%c != 0:
        lst.append(i)
for j in lst:
    if j%d != 0:
        cnt += 1
print(cnt)

### FIXED CODE ###

a, b, c, d = map(int, input().split())
i, j = c, d
def gcd(i, j):
    return i if j == 0 else gcd(j, i%j)
lcm = int(c//gcd(c, d)*d)

def cont(x):
    cnt1 = x//c 
    cnt2 = x//d
    ans = x - cnt1 - cnt2 + x//lcm
    return int(ans)

print(cont(b) - cont(a-1))
### BUGGY CODE ###

n = int(input())
s = input()

l = []
for i in range(n):
    if i == 0:
        l.append(1)
        continue
    if s[i] == s[i-1]:
        l[-1]+=1
    else:
        l.append(1)

if s[0]=='.':
    l = l[1:]
if s[-1]=='#':
    l = l[:-1]

bw = sum(l[1::2])

for i in range(len(l)//2+1):
    bw = min(bw, sum(l[:2*i+1:2])+sum(l[2*i+1::2]))

print(bw)


### FIXED CODE ###

n = int(input())
s = input()

black = 0
white = s.count('.')

ans = white + black

for i in range(n):
    if s[i] == '#':
        black += 1
    else:
        white -= 1
    ans = min(ans, white + black)

print(ans)
### BUGGY CODE ###

num = []
for _ in range(int(input())):
    num.append(int(input()))

for i in range(len(num)):
    a = max(num[:i]) if i > 0 else -1e9
    b = max(num[i+1:]) if i < len(num)-1 else -1e9
    print(max(a, b))

### FIXED CODE ###

num = []
aaa = []
nmax = 0
n2max = 0
count = 0
n = int(input())
for i in range(n):
    a = int(input())
    aaa.append(a)
    if(nmax < a):
        n2max = nmax
        nmax = a
        count = 1
        num = [i]
    elif(nmax == a):
        count += 1
        num.append(i)
    elif(n2max < a):
        n2max = a
for i in range(len(aaa)):
    if(count >= 2) or (nmax != aaa[i]):
        print(nmax)
    else:
        print(n2max)
### BUGGY CODE ###

def solve(N, As):
    total = 0
    for i in range(N - 1):
        for j in range(i + 1, N):
            total += As[i] * As[j]
    ans = total % (10 ** 9 + 7)
    print(ans)


if __name__ == "__main__":
    N = int(input())
    As = list(map(int, input().split()))
    solve(N, As)


### FIXED CODE ###

def solve(N, As):
    Ss = [0]
    total = 0
    for a in As:
        Ss.append(Ss[-1] + a)
    for i in range(N - 1):
        total += As[i] * (Ss[-1] - Ss[i + 1])
    ans = total % (10 ** 9 + 7)
    print(ans)


if __name__ == "__main__":
    N = int(input())
    As = list(map(int, input().split()))
    solve(N, As)
### BUGGY CODE ###

n = int(input())
s = [input() for _ in range(n)]
ans = 0

for i in range(n):
	for k in range(n):
		if sorted(s[i]) == sorted(s[k]) :
			ans += 1

print(int((ans - n) / 2))


### FIXED CODE ###

n = int(input())
s = ["".join(sorted(input())) for _ in range(n)]
ans = 0
s_dic = {i:0 for i in s}

for j in range(n):
	if s[j] in s_dic :
		s_dic[s[j]] += 1

print(sum(s_dic[k] * (s_dic[k] - 1) // 2 for k in s_dic))
### BUGGY CODE ###

N = int(input())
S = []
ans = N
for i in range(N):
    S.append(input())
    for j in range(i):
        if i != j:
            if S[j] == S[i]:
                S[j] = ''
                ans = ans - 1
print(ans)

### FIXED CODE ###

N = int(input())
S = []
ans = N
S = [input() for i in range(N)]
#for i in range(N):
#    S.append(input())
S.sort()
for i in range(N-1):
    if S[i] == S[i+1]:
        ans = ans - 1
print(ans)
### BUGGY CODE ###

#!/usr/bin/env python3
import sys
from itertools import accumulate
sys.setrecursionlimit(10**8)
INF = float("inf")


def solve(N: int, a: "List[int]"):

    acc = [0]+list(accumulate(a))

    dp = [[-1]*N for _ in range(N)]

    def rec(l, r):
        if dp[l][r] > 0:
            return dp[l][r]
        if l == r:
            return 0

        wa = acc[r+1]-acc[l]
        ans = INF
        for k in range(l, r):
            ans = min(rec(l, k) + rec(k+1, r), ans)
        dp[l][r] = ans + wa
        return dp[l][r]

    print(rec(0, N-1))
    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    a = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(N, a)


if __name__ == '__main__':
    main()


### FIXED CODE ###

#!/usr/bin/env python3
import sys
from itertools import accumulate
import functools
sys.setrecursionlimit(10**8)
INF = float("inf")


def solve(N: int, a: "List[int]"):

    dp = [[-1]*N for _ in range(N)]
    acc = [0]+list(accumulate(a))

    def rec(l, r):
        if dp[l][r] > 0:
            return dp[l][r]
        if l == r:
            return 0

        wa = acc[r+1]-acc[l]
        ans = INF
        for k in range(l, r):
            ans = min(rec(l, k) + rec(k+1, r), ans)
        dp[l][r] = ans + wa
        return dp[l][r]

    print(rec(0, N-1))
    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    a = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(N, a)


if __name__ == '__main__':
    main()
### BUGGY CODE ###

def main():
    A, B, C, D = map(int, input().split())

    while True:
        Aoki_health = C-B
        Take_health = A-D
        if Take_health < 1 <= Aoki_health:
            print('No')
            break
        if Take_health >= 1 > Aoki_health:
            print('Yes')
            break


if __name__ == '__main__':
    main()

### FIXED CODE ###

import math


def main():
    A, B, C, D = map(int, input().split())

    Takeshi = math.ceil(C/B)
    Aoki = math.ceil(A/D)

    print('Yes' if Takeshi<= Aoki else 'No')


if __name__ == '__main__':
    main()
### BUGGY CODE ###

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

for i in range(n):
    x = a.pop(i)
    ans, c = 0, 0
    for j in a:
        ans += abs(c-j)
        c = j
    a.insert(i, x)
    ans += abs(c-0)
    print(ans)


### FIXED CODE ###

n = int(input())
a = [0] + list(map(int, input().split())) + [0]
s = sum([abs(a[i]-a[i-1]) for i in range(1, n+2)])
for i in range(1, n+1):
    x = abs(a[i]-a[i-1])
    y = abs(a[i+1]-a[i])
    z = abs(a[i+1]-a[i-1])
    print(s-x-y+z)
### BUGGY CODE ###

import copy

def com(n,r,m):
    #a = math.factorial(n)%m
    a = 1
    for i in range(1,n+1):
        a *= i
        a %= m
    A = pow(a,m-2,m)
    
    
    b= copy.copy(A)   
    for i in range(n,r,-1):
        b = (b*i)%m
    
    c = copy.copy(A)
    for i in range(n,n-r,-1):
        c = (c*i)%m
       
    return (a*b*c)%m

def main():
    k = int(input())
    s = input()
    mod = 10**9+7

    ans = 0
    p = 1   #pow(25,i-len(s),mod)
    q = pow(26,k,mod)
    bai = 1
    for i in range(len(s),len(s)+k+1):
        base = p*q   #pow(26,len(s)+k-i,mod)
        #base = pow(25,i-len(s),mod) * pow(26,len(s)+k-i,mod)
        #bai = r
        #bai = com(i-1,len(s)-1,mod)
        #print(i,len(s),base,bai)
        ans += base*bai
        ans %= mod
        p *= 25
        q *= pow(26,mod-2,mod)
        bai = bai*i*pow(i-len(s)+1,mod-2,mod)
    print(ans)
    
if __name__=="__main__":
    main()

### FIXED CODE ###

import copy

def com(n,r,m):
    #a = math.factorial(n)%m
    a = 1
    for i in range(1,n+1):
        a *= i
        a %= m
    A = pow(a,m-2,m)
    
    
    b= copy.copy(A)   
    for i in range(n,r,-1):
        b = (b*i)%m
    
    c = copy.copy(A)
    for i in range(n,n-r,-1):
        c = (c*i)%m
       
    return (a*b*c)%m

def main():
    k = int(input())
    s = input()
    mod = 10**9+7
    z = [1]
    for i in range(1,k+1):
        y = z[-1]*26
        z.append(y%mod)
    l = len(s)

    N = k+2
    inv_t = [0]+[1]
    for i in range(2,N):
        inv_t.append(inv_t[mod % i] * (mod - int(mod / i)) % mod)
    #print(inv_t)
    
    ans = 0
    p = 1   #pow(25,i-len(s),mod)
    #q = z[k]
    bai = 1
    for i in range(l,l+k+1):
        #base = p*q   #pow(26,len(s)+k-i,mod)
        #base = pow(25,i-len(s),mod) * pow(26,len(s)+k-i,mod)
        #bai = r
        #bai = com(i-1,len(s)-1,mod)
        #print(i,len(s),base,bai)
        ans += p*z[l+k-i]*bai
        ans %= mod
        p *= 25
        p %= mod
        #q = z[l+k-i-1]
        bai = bai*i*inv_t[i+1-l]
        bai %= mod
    print(ans)
    
if __name__=="__main__":
    main()