peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Accepted
n,l = map(int,input().split())
s = int(n*(2*l+n-1)/2)
if(l<=0 and l+n-1 >=0):
  print(s)
elif(l<=0):
  print(s-l-n+1)
else:
  print(s-l)
# Judge status: Wrong Answer
import sys
input=sys.stdin.buffer.readline
n,a,b=map(int,input().split())
S=input()[:-1]
print(n,a,b,S)
for i in range(n):
    A=S[:i].count(97)
    B=S[:i].count(98)
    if S[i]==97 and A+B<=a+b:
        print("Yes")
        continue
    if S[i]==98 and A+B<a+b and B<b:
        print("Yes")
        continue
    else:print("No")
# Judge status: Accepted
def maximumx(N, S) : 
  x = 0
  max = 0
  
  for i in range(N) : 
    if S[i] == 'I' : 
      x += 1
      if max < x :
        max = x
    else : 
      x -= 1 
      
  return max


N = int(input())
S = input()

print(maximumx(N, S))
# Judge status: Accepted
n = int(input())
from math import ceil
def g(x, n):
    y = n // x
    return int(x * (y + 1) * y /2 )
print(sum(g(i+1, n) for i in range(n)))
# Judge status: Wrong Answer
S=list(map(str,input()))
cnt1=0
cnt2=0
if S[0]!=S[1]:
    for i in range(1,4):
        if S[0]==S[i]:
            cnt1 +=1
            break
    for j in range(2,4):
        if S[1]==S[j]:
            cnt2 +=1
            break
    if cnt1==1 and cnt2==1:
        print("Yes")
    else:print("No")
elif S[0]==S[1] and S[2]==S[3]:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
N,K = map(int,input().split())
H = list(map(int,input().split()))
ans = 0

if N <= K:
  print(ans)
else:
  H.sort(reverse=True)
  del H[:K]
  ans = sum(H)
  print(ans)
# Judge status: Accepted
n = int(input())
if n < 1000:
  print('ABC')
else:
  print('ABD')
# Judge status: Accepted
a,b,c,d,e,k=[int(input()) for i in range(6)]
if e-a<=k:
  print("Yay!")
else:
  print(":(")
# Judge status: Accepted
n = int(input())
a = list(map(int,input().split()))
if n % 2 == 0:
    start = n - 1
    while start >= 0:
        print(a[start],end=' ')
        start -= 2
    start = 0
    while start < n:
        print(a[start],end=' ')
        start += 2
elif n % 2 == 1:
    start = n - 1
    while start >= 0:
        print(a[start],end=' ')
        start -= 2
    start = 1
    while start < n:
        print(a[start],end=' ')
        start += 2
# Judge status: Wrong Answer
A, B, C = map(int, input().split())
if A==B and B==C :
  print(1)

elif A==B and B!=C :
  print(2)

elif B==C and B!=A :
  print(2)

elif A==C and A!=B :
  print(2)

else :
  print(1)
# Judge status: Accepted
w, h, n = map(int, input().split())

x_min = 0
y_min = 0
x_max = w
y_max = h
for i in range(n):
    x, y, a = map(int, input().split())
    
    if a == 1:
        x_min = max(x_min, x)
    elif a == 2:
        x_max = min(x_max, x)
    elif a == 3:
        y_min = max(y_min, y)
    else:
        y_max = min(y_max, y)

if x_max <= x_min or y_max <= y_min:
    print(0)
else:
    print((x_max - x_min) * (y_max - y_min))
# Judge status: Accepted
# A - Simple Calculator

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

def f(x):
    if x<0:
        return 10**10
    else:
        return x
ans = min(f(y-x), f(y+x)+1, f(-y-x)+1, f(-y+x)+2)
print(ans)
# Judge status: Wrong Answer
N, M = map(int, input().split())
PS = [list(input().split()) for _ in range(M)]

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

cnt = 0
ans = 0
for p, s in PS:
    if C[int(p)] == 0:
        if s == "WA":
            cnt += 1
        else:
            C[int(p)] += 1
            ans += 1


print(ans, cnt)
# Judge status: Accepted
A, B, C = map(int, input().split())
K = int(input())
print(sum([A, B, C])+max(A, B, C)*2**K-max(A, B, C))
# Judge status: Accepted
N = int(input())
A = list(map(int,input().split()))
 
ans = 'APPROVED'
for i in A:
    if i % 2 == 0:
        if i % 3 == 0:
            pass
        elif i % 5 == 0:
            pass
        else:
            ans = 'DENIED'
print(ans)
# Judge status: Accepted
import sys
input = lambda: sys.stdin.buffer.readline()

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

m = 10**6+10
d = [False] * (m+1)
ans = 0
for i in range(n):
    same = (i > 0 and a[i] == a[i-1]) or (i < (n-1) and a[i] == a[i+1])
    x = a[i]
    if not d[x] and not same: ans += 1
    
    if (i > 0 and a[i] == a[i-1]): continue
    for j in range(x, m+1, x):
        d[j] = True
    
print(ans)
# Judge status: Accepted
n,k = map(int,input().split())

ans = 0
for i in range(k,n+1) :
  # i個使う場合の最小値
  min_i = (i-1)*i//2
  # i個使う場合の最大値
  max_i = (n-i+1+n)*i//2
  ans += (max_i-min_i+1)
  
print(ans%(10**9+7)+1)
# Judge status: Accepted
def main():
  num = [int(input()) for i in range(5)]
  n =int(input())
  flg=0
  for i in range(0,4):
    for j in range(i,5):
      if abs(num[j]-num[i])>n :
        flg=1
        break
  if flg==0 :
    print('Yay!')
  else :
    print(':(')

main()
# Judge status: Accepted
N = int(input())
if (N % 1000) == 0:
	ans = 0
else:
	ans = 1000 - (N % 1000)
print(ans)
# Judge status: Accepted
n = int(input())
nums = [int(i) for i in input().split()]
box = [-1] * n
for i in range(1, n + 1)[::-1]:
    c = i * 2
    ball = nums[i - 1]
    while c <= n:
        ball = ball ^ box[c - 1]
        c += i
    box[i - 1] = ball

ans = box.count(1)
print(ans)
ball = []
for i in range(n):
    if box[i] == 1:
        ball.append(i + 1)
print(*ball)
# Judge status: Accepted
n = int(input())

keta = len(str(n))
cnt = 0

for i in range(keta):
    if i%2 != 0: #odd
        cnt += 10**i - 10**(i-1)
    if i == keta-1 and keta%2 != 0:
        cnt += n - 10**(keta-1) + 1

print(cnt)
# Judge status: Wrong Answer
# -*- coding: utf-8 -*-

## Library

import sys
from fractions import gcd
import math
from math import ceil,floor
import collections
from collections import Counter

## input

# n=int(input())
# A,B,C,D=map(int, input().split())
# string = input()
# yoko = list(map(int, input().split()))
# tate = [int(input()) for _ in range(N)]
# N, M = map(int,input().split()) 
#    P = [list(map(int,input().split())) for i in range(M)]


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

V.sort()
tmp = (V[0]+V[1])/2
for i in range(2,N):
    print(i,tmp)
    tmp = (tmp + V[i])/2

print(tmp)
# Judge status: Accepted
N = int(input())
D = {}
ans = 0

for _ in range(N):
    S = input()
    if S not in D:
        D[S] = True
        ans += 1

print(ans)
# Judge status: Wrong Answer
n = int(input())
a = [int(i)-1 for i in input().split()]
ans = 0
for i in range(n):
    if a[i] != (i - ans):
        ans += 1
print(ans if ans != n else 0)
# Judge status: Wrong Answer
N = int(input())
N_ = str(N)
n = len(N_)

if n == 1:
    print(N)
    exit()

for i in range(1, n):
    if N_[i] != '9':
        break
else:
    ans = int(N_[0]) + 9*(n-1)

ans = int(N_[0])-1 + 9*(n-1)

print(ans)
# Judge status: Accepted
X = int(input())

n = 1
nX = [X]
k = 360
mk = [360]

while True:
    if mk.count(nX[-1]) == 1:
        print(n)
        break
    n += 1
    mk.append(n * k)
    nX.append(n * X)
# Judge status: Accepted
N, K = map(int, input().split())
*A, = map(int, input().split())
visited = [False] * N
towns = []
now = 0
length = 0
while not visited[now] and K > 0:
    visited[now] = True
    towns.append(now + 1)
    length += 1
    K -= 1
    now = A[now] - 1
if K == 0: print(now + 1)
else:
    idx = towns.index(now + 1)
    length -= idx
    print(towns[idx:][K % length])
# Judge status: Accepted
n = int(input())
st = []
for i in range(n):
    x, l = map(int, input().split())
    st.append([x + l, x - l])

st.sort()
cnt = 1
right = st[0][0]
for i in range(1, n):
    if right <= st[i][1]:
        right = st[i][0]
        cnt += 1

print(cnt)
# Judge status: Accepted
from sys import stdin
import math

a,b=map(int,input().split())
print((a+b+1)//2)
# Judge status: Wrong Answer
n = int(input())
A = [int(input()) for _ in range(n)]

ans = 0
b = float('inf')
for a in A:
  if a <= b:
    b = a
    ans += 1
print(ans)
# Judge status: Wrong Answer
N = int(input())
s = [input() for i in range(N)]
M = int(input())
t = [input() for i in range(M)]

st_dict = {}

for i in range(N):
    if s[i] not in st_dict.keys():
        st_dict[s[i]] = 1
    else:
        st_dict[s[i]] += 1
for i in range(M):
    if t[i] not in st_dict.keys():
        st_dict[t[i]] = -1
    else:
        st_dict[t[i]] -= 1

print(max(st_dict.values()))
# Judge status: Wrong Answer
x, y = map(int, input().split())

MAX = 10**6+1
MOD = 10**9+7
fac = [0, 1]
for i in range(2, MAX):
    fac.append(fac[i-1] * i % MOD)

if (x % 3 == 0 and y % 3 == 0) or (min(x % 3, y % 3) == 1 and max(x % 3, y % 3) == 2):
    xx, yy = max(x, y), min(x, y)
    a = b = 0
    while not xx == yy:
        xx -= 2
        yy -= 1
        a += 1
    a += xx // 3
    b += yy // 3
    print(fac[a+b] * pow(fac[a]*fac[b], MOD-2, MOD) % MOD)
else:
    print(0)
# Judge status: Accepted
X = int(input())
ans = 100
year = 0

while ans < X:
    year += 1
    ans = int(ans*1.01)
print(year)
# Judge status: Wrong Answer
import math
H, W = map(int, input().split())
 
ans = 0

if H==1 or W==1:
  print(1)
  exit()

if H%2 == 0:
  len = int(H/2)
  ans += int(math.ceil(W/2))*len + int(math.floor(W/2))*len
else:
  len = int(math.floor(H/2))
  ans += int(math.ceil(W/2))*(len+1) + int(math.floor(W/2))*len
  print(ans)
  
print(int(ans))
# Judge status: Accepted
N,K = [int(i) for i in input().split()]
print(1 + (max(0, N - K) + (K-2))//(K-1))
# Judge status: Wrong Answer
n, *A = map(int, open(0).read().split())
x = 0
for i in range(n):
  x, A[x] = A[x]-1, 0
  if x == -1:
    print(-1)
    exit()
  if x == 1:
    print(i+1)
    exit()
# Judge status: Accepted
N, *AB = map(int, open(0).read().split())
AB = [(B, -A) for A, B in zip(AB[::2], AB[1::2])]
AB.sort()
t = 0
for b, a in AB:
    a = -a
    t += a
    if t > b:
        print("No")
        break
else:
    print("Yes")
# Judge status: Accepted
from fractions import gcd
N=int(input())
def lcm(a,b):
    return a//gcd(a,b)*b
T=[]
for i in range(N):
    t=int(input())
    T.append(t)
a=1
for i in range(N):
    a=lcm(a,T[i])

print(a)
# Judge status: Wrong Answer
a,b = input().split()
cnt = 0
A1 = int(a[0])*10+int(a[1])
A2 = int(a[-2])*10+int(a[-1])
B1 = int(b[0])*10+int(b[1])
B2 = int(b[-2])*10+int(b[-1])
if A1 -A2 >= 0:
    cnt += 1
if B1 - B2 > 0:
    cnt -= 1
cnt += (int(b)-int(a))//100
print(cnt)
# Judge status: Wrong Answer
n,m = map( int,input().split() )
k = [ list(map( int,input().split() )) for _ in range(n) ]

c = [0] * (m+1)

for i in k:
  for j,data in enumerate(i):
    if j == 0:
      continue
    else:
      c[data] += 1

ans = 0
for i in c:
  if i == 3:
    ans += 1

print(ans)
# Judge status: Accepted
N,M = map(int,input().split())
AB = []
for i in range(N):
    A,B = map(int,input().split())
    AB.append((A,B))
AB.sort()
cnt = 0
ans = 0
for a,b in AB:
    if cnt+b >= M:
        break
    cnt += b
    ans += a*b
ans += a*(M-cnt)
print(ans)
# Judge status: Wrong Answer
from sys import stdin
import collections
import math


n,x   = [int(x) for x in stdin.readline().rstrip().split()]
arr = [int(x) for x in stdin.readline().rstrip().split()]

ans = 0
for i in range(0,n-1):
    s = arr[i] + arr[i+1]
    if s > x :
        d = s-x
        arr[i+1] -= s - x
        ans += d

print(ans)
# Judge status: Wrong Answer
a,b =map(int,input("数字を入力してください").split())
print(a*b)
# Judge status: Accepted
import numpy as np
n=int(input())
num=np.array(list(range(1,n+1)))

x=n//num
ans=num*(x+1)*x/2
print(int(np.sum(ans)))
# Judge status: Accepted
S = list(str(input()))
if S[0] == S[1] and S[2] == S[3] and S[0] != S[2]:
    print('Yes')
elif S[0] == S[2] and S[1] == S[3] and S[0] != S[1]:
    print('Yes')
elif S[0] == S[3] and S[1] == S[2] and S[0] != S[1]:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
N = int(input())
a = list(map(int,input().split()))
ans = [0 for i in range(N+1)]

for i in range(N,0,-1):
    res = 0
    for j in range(1,N+1):
        if i*j>N:
            break
        else:
            res += ans[i*j]
      
    if res%2 != a[i-1]:
        ans[i] += 1
        
print(sum(ans))
A = []
for i,v in enumerate(ans):
    if v>0:
        A.append(i)
        
        
print(*A)
# Judge status: Accepted
A, B, C = map(int,input().split())
if (A - C) * (B - C) < 0:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
sh,sm,fh,fm,k = map(int,input().split())
h = 0
m = 0
ans = 0

if sm > fm:
    h = 60*(fh-sh)
    m = sm -fm
    ans = h - m - k
else:
    h = 60*(fh-sh)
    m = fm -sm
    ans = h + m - k  

print(ans)
# Judge status: Accepted
a,b,c=map(int,input().split())
d,e,f=map(int,input().split())
g,h,i=map(int,input().split())
n=int(input())
B=[int(input()) for j in  range(n)]
 
if (a in B and b in B  and c in B) or (d in B and e in B  and f in B) or (g in B and h in B and i in B) or (a in B and d in B and g in B) or (b in B and e in B and h in B) or (c in B and f in B and i in B) or (a in B and e in B and i in B) or (c in B and e in B and g in B):
    print("Yes")
else:
    print("No")
# Judge status: Accepted
a,b,c,d=map(int,input().split())
print("Yes"if abs(c-a)<=d or (abs(b-a)<=d and abs(c-b)<=d) else "No")
# Judge status: Wrong Answer
W, H, N = [int(i) for i in input().split()]

xya = []

for _ in range(N):
    xya.append([int(i) for i in input().split()])

xmin = 1
ymin = 1
xmax = W
ymax = H

for i in xya:
    if i[2] == 1:
        xmin = i[0]
    elif i[2] == 2:
        xmax = i[0]
    elif i[2] == 3:
        ymin = i[1]
    else:
        ymax = i[1]

s = (xmax - xmin) * (ymax - ymin)
print(s)
# Judge status: Accepted
import math
def main():
  n = int(input())
  a = list(map(int,input().split()))
  a.sort(reverse=True)
  alice=sum(a[::2])
  bob=sum(a[1::2])
  print(alice-bob)
main()
# Judge status: Wrong Answer
def step(N, A):
    sum = 0
    for i in range(1, N):
        if A[i-1] < A[i]:
            sum += A[i] - A[i-1]
    return sum
if __name__ == "__main__":
    N = int(input())
    A = list(map(int, input().split()))
    print(step(N, A))
# Judge status: Accepted
inp = int(input())

def solve(value):
    current = 100
    for i in range(1000000):
        current = int(current * (1.01**1))
        if current >= value:
            print(i+1)
            return

solve(inp)
# Judge status: Wrong Answer
import sys
input = sys.stdin.readline
N, M = map(int, input().split())
res = []
for k in range(1, M + 1):
  res.append((k, N - k))
for r in res: print(*r)
# Judge status: Wrong Answer
A,B,K=map(int,input().split())
if A>=K:
    A-=K
else:
    B=A+B-K
    A=0
print(A,B)
# Judge status: Accepted
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np
from functools import reduce

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

s = rr()
for char in 'abcdefghijklmnopqrstuvwxyz':
    if char not in s:
        print(char)
        exit()
else:
    print('None')
# Judge status: Accepted
n = int(input())
li = list(map(int,input().split()))
li.sort(reverse=True)
print(sum(li[1:2*n:2]))
# Judge status: Accepted
from bisect import bisect_right


N, *A = map(int, open(0).read().split())
A = [-a for a in A]
q = []
for a in A:
    idx = bisect_right(q, a)
    if idx == len(q):
        q.append(a)
    else:
        q[idx] = a
print(len(q))
# Judge status: Wrong Answer
# import math
# x, y = map(int, input().split())
# a = (4 * x - y) / 2
# if a >= 0 and a <= x and a == math.ceil(a):
#     print('Yes')
# else:
#     print('No')
x, n = map(int, input().split())
p = list(map(int, input().split()))
if n == 0:
    print(x)
for i in range(n):
    if x - i not in p:
        print(x - i)
        break
    elif x + i not in p:
        print(x + i)
        break
# Judge status: Accepted
import fractions
from functools import reduce
def g(n):
    return reduce(fractions.gcd,n)
n=int(input())
print(g(list(map(int,input().split()))))
# Judge status: Wrong Answer
def main():
  S = str(input())
  ans = 0
  num_s = 0
  flag = False
  for i in range(len(S)):
    if S[i] == 'S' and flag:
      num_s = 0
      flag = False
    if S[i] == 'S':
      num_s += 1
    if S[i] == 'T':
      flag = True
      if num_s > 0:
        ans += 2
        num_s-=1
  print(len(S)-ans)
  
if __name__ == "__main__":
  main()
# Judge status: Accepted
x = int(input())
n, y = 100, 0
while n < x:
    n = n * 101 // 100
    y = y + 1
print(y)
# Judge status: Accepted
import sys

def solve():
    input = sys.stdin.readline
    L = [int(i) for i in input().split()]
    count = 0
    L.sort()
    addMin = (L[2] - L[0]) // 2  
    addMid = (L[2] - L[1]) // 2
    count = addMin + addMid
    L[0] += addMin * 2
    L[1] += addMid * 2
    if L[0] < L[2] and L[1] < L[2]: print(count + 1)
    elif L[0] == L[1] == L[2]: print(count)
    else: print(count + 2)
    #print(L)

    return 0

if __name__ == "__main__":
    solve()
# Judge status: Wrong Answer
def main():
    N = int(input())
    A = list()

    for i in range(N):
        a, b = map(int, input().split())
        A.append([a, b])

    A.reverse()
    ans = 0
    offset = 0

    for pair in A:
        a, b = pair

        if a % b == 0:
                continue
        else:
            n = b - ((a + offset) % b)
            ans += n
            offset += n
    
    print(ans)

if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
a=int(input())
b=1
for i in range(1,a):
  b=b*i
print(b%1000000007)
# Judge status: Accepted
def manhattan(n, x, y):
    x2 = [0] * n
    y2 = [0] * n
    for i in range(n):
        x2[i] = x[i] - y[i]
        y2[i] = x[i] + y[i]
    print(max(max(x2) - min(x2), max(y2) - min(y2)))

n = int(input())
x = [0] * n
y = [0] * n
for i in range(n):
    x[i] , y[i] = map(int, input().split())
manhattan(n, x, y)
# Judge status: Wrong Answer
from collections import deque
 
n = int(input())
a = list(map(int,input().split()))
d = deque(a)
 
tmp = []
cnt = 0
while d:
  v = d.popleft()
  if len(tmp)<=1:
    pass
  else:
    if not (v >= tmp[-1] >= tmp[-2] or v <= tmp[-1] <= tmp[-2]):
      tmp = []
      cnt += 1
  tmp.append(v)
#  print(d,tmp,cnt)
if tmp:
  cnt+=1
print(cnt)
# Judge status: Accepted
n, d = map(int, input().split())
point = [[int(i) for i in input().split()] for j in range(n)]
count = 0
for i in range(n):
    for j in range(i + 1, n):
        norm = 0
        for pi, pj in zip(point[i], point[j]):
            norm += (pi - pj) ** 2
        if int(norm**0.5) == norm**0.5:
            count += 1

print(count)
# Judge status: Accepted
n = int(input())
A = list(map(int, input().split()))

count = 0
find = 1
for i in range(n):
    if A[i] == find:
        find += 1
    else:
        count += 1
print(count if count != n else -1)
# Judge status: Accepted
n, x = map(int, input().split())
l = list(map(int, input().split()))
res = 0
for i in range(n):
    res += l[i]
    if x < res:
        print(i+1)
        exit()
print(i+2)
# Judge status: Accepted
N, K = map(int, input().split())
hs = []
for _ in range(N):
  hs.append(int(input()))
hs.sort()
  
start, end = 0, K-1
ans = float('inf')
while end < N:
  ans = min(ans, hs[end]-hs[start])
  start += 1
  end += 1
  
print(ans)
# Judge status: Wrong Answer
N, D = map(int, input().split())
X = []
for i in range(N):
  X.append(list(map(int, input().split())))
print(X)

ans = 0
for i in range(N):
  for j in range(i+1, N):
    dist_sq = 0
    for x, y in zip(X[i], X[j]):
      dist_sq += (x - y) ** 2

    dist = dist_sq ** 0.5
    print(i, j, dist)

    if dist - int(dist) == 0:
      ans += 1

print(ans)
# Judge status: Accepted
n = int(input())
#n, k = map(int, input().split())
al = list(map(int, input().split()))
#al=[list(input()) for i in range(n)]


def color(rate):
    c = rate//400
    return min(8, c)


dic = {i: 0 for i in range(9)}

for a in al:
    dic[color(a)] = dic[color(a)]+1

count = 0
for i in range(8):
    if dic[i] != 0:
        count += 1

mn = count
mx = count
if dic[8] != 0:
    if count>=1:
        mx = mn+dic[8]
    else:
        mn=1
        mx=dic[8]

print(mn, mx)
# Judge status: Accepted
n = int(input())
number = list(map(int, input().split()))
cnt = 0
min_num = number[0]
for i in range(n):
  if min_num >= number[i]:
    cnt += 1
    min_num = number[i]
  else:
    continue
print(cnt)
# Judge status: Wrong Answer
a = int(input())
r = 1
for i in range(1790,598,-200):
    if a <= i:
        r += 1
print(r)
# Judge status: Wrong Answer
arr=raw_input()
for i in range(len(arr)):
  if arr[i]==9:
    print "Yes"
  else:
    print "No"
# Judge status: Accepted
N = int(input())
S = list(input())
cnt = (S[1:]).count("E")
ans = cnt
for i in range(1,N):
  if S[i] == 'E':
    cnt -= 1
  if S[i-1] == 'W':
    cnt += 1
  ans = min(ans,cnt)
print(ans)
# Judge status: Accepted
x,y = map(int, input().split())
a = [1,3,5,7,8,10,12]
b = [4,6,9,11]
c = [2]
if x in a and y in a  or  x in b and y in b:
  print("Yes")
else:
  print("No")
# Judge status: Accepted
def solve(a,b):
  if a <= 0 and b >= 0:
    return "Zero"
  elif a < b < 0 and (b-a+1) % 2 == 1:
    return "Negative"
  else:
    return "Positive"
    

a,b = map(int,input().split())
print(solve(a,b))
# Judge status: Accepted
sx,sy,tx,ty = map(int, input().split())

diff_x = tx-sx
diff_y = ty-sy

first_path = 'U'*diff_y + 'R'*diff_x + 'D'*diff_y + 'L'*diff_x
second_path = 'L' + 'U'*diff_y + 'U' + 'R' + 'R'*diff_x + 'D' + \
              'R' + 'D'*diff_y + 'D' + 'L' + 'L'*diff_x + 'U'


print(first_path+second_path)
# Judge status: Accepted
n,m=map(int,input().split())
d={i:[] for i in range(n)}
n-=1
for i in range(m):
    a,b=map(int,input().split())
    a-=1
    b-=1
    d[a].append(b)
    d[b].append(a)
for i in d[0]:
    if n in d[i]:
        print('POSSIBLE')
        exit()
print('IMPOSSIBLE')
# Judge status: Accepted
D,N=map(int,input().split())
p=0
if N==100:
  print(pow(100,D+1)+pow(100,D))
else:
  print(pow(100,D)*N)
# Judge status: Accepted
x, y = map(int, input().split())

ga = [4,6,9,11]
gb = [1,3,5,7,8,10,12]
gc = [2]

xg = yg = ""
def group(x):
  if x in ga:
    return "ga"
  if x in gb:
    return "gb"
  if x in gc:
    return "gc"
xg = group(x)
yg = group(y)
if xg == yg:
  print("Yes")
else:
  print("No")
# Judge status: Accepted
S = input()

if S == "ARC":
	ans = "ABC"
else:
	ans = "ARC"
print(ans)
# Judge status: Accepted
from functools import reduce

N = int(input())
div = pow(10, 9) + 7
print(reduce(lambda ans, n: ans * n % div, range(1, N + 1)))
# Judge status: Wrong Answer
n=int(input())
l=list(map(int,input().split()))

c_4=0
even=0
odd=0

for i in l:
  if i%4==0:
    c_4+=1
  elif i%2==0:
    even+=1
  else:
    odd+=1
  
if even==0 and odd <= c_4:
  ans="Yes"
else:
  ans="No"
  
if even>0 and odd <= c_4:
  ans="Yes"
else:
  "No"

print(ans)
# Judge status: Accepted
a = input()
if a.isupper()==1:
    print("A")
else:
    print("a")
# Judge status: Accepted
w=input()
x=list(sorted(set(w)))

flag=1
for i in x:
  if w.count(i)%2!=0:
    flag=0
    break
print('Yes' if flag==1 else 'No')
# Judge status: Accepted
a,b,c = map(int,input().split())

if c > a+b and 4*a*b < (c-a-b)**2:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
import math
x=int(input())
a=100
result=0
while a<x:
  a=math.floor(a*1.01)
  result+=1
print(result)
# Judge status: Accepted
import collections, math

def combinations_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

N, P = map(int, input().split())
A = list(map(int, input().split()))
for i in range(N):
    A[i] = A[i] % 2
c = collections.Counter(A)
zero = c[0]
one = c[1]

ans = 0
if P == 0:
    for i in range(0, one + 1, 2):
        ans += (2 ** zero) * (combinations_count(one, i) )
else:
    for i in range(1, one + 1, 2):
        ans += (2 ** zero) * (combinations_count(one, i) )
print(ans)
# Judge status: Accepted
n = int(input())
while n >= 10:
    n = n % 10

if n == 2 or n==4 or n == 5 or n==7 or  n== 9:
    print('hon')
elif n == 0 or n==1 or n == 6 or n==8:
    print('pon')
elif n== 3:
    print('bon')
# Judge status: Accepted
w,h,x,y = map(int,input().split())

half = w*h/2
msg = 0
if x == w/2 and y == h/2:
    msg = 1
print(half, msg)