Harryxun/stf_run huggingface dataset:
a, v = list(map(long, input("").split()))
b, w = list(map(long, input("").split()))
t = long(input(""))

if b > a:
    if a + v * t >= b + w * t:
        print("YES")
    else:
        print("NO")
else:
    if v > w:
        print("NO")
    else:
        if b + w * t >= a + v * t:
            print("YES")
        else:
            print("No")


### FIXED CODE ###

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

l  = abs(a-b)

if (v - w) * t >= l:
    print("YES")
else:
    print("NO")
n, m = map(int,input().split())
if n%2 == 1:
    if m
    print(-1)
    exit()
else:
    if m >= n:
        print(-1)
        exit()

list1 = [0]*n
k = 2
for j in range(1,n):
    if j == len(list1)-j:
        list1[j] = 1
        break
    list1[j] = k
    list1[len(list1)-j] = k
    k = k+1

list2 = [0]*n
for j in range(1,n):
    if j == len(list2)-j:
        list2[j] = 1
        break
    list2[j] = k
    list2[len(list2)-j] = k
    k = k+1

li = list1 + list2

for i in range(len(li)):
    if li[i] == m:
        li[i] = 1
    elif li[i] == 1:
        li[i] = m
print(li)

### FIXED CODE ###

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

if 2**m <= k:
    print(-1)
    exit()

if m == 1:
    if k == 0:
        print("0 0 1 1")
    if k == 1:
        print(-1)
    exit()

li = []
for i in range(2**m):
    if i != k:
        li.append(i)
li = li + [k] + list(reversed(li)) + [k]
print(" ".join(map(str, li)))
import math

n = int(input())
print(math.factrial(n) % (10^9 + 7))

### FIXED CODE ###

import math
 
n = int(input())
inf = 10**9 + 7
s = math.factorial(n)
print(s%inf)
a = int(input())

b = []

for i in a:
    b.append(input().split())

res = 0

num = a.pop(0) * 2

for i in len(b):
    if (b[i] == 'BTC'):
        c = int(a[i-1]) * 380000
        res += c
    elif (b[i] == 'JPY'):
        res += int(b[i-1])
    else:
        pass

print(res) 

### FIXED CODE ###

a = int(input())

b = []

for i in range(a):
    b.append(input().split())

res = 0

for i in b:
    if (i[1] == 'BTC'):
        res += float(i[0])*380000
    else:
        res += int(i[0])

print(res)
a,b,c = [int(i) for i in input().split()]

if ([a,b,c].count(a) = 1) :
	print(a)
elif ([a,b,c].count(b) = 1) :
	print(b)
else :
	print(c)


### FIXED CODE ###

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

if ([a,b,c].count(a) == 1) :
	print(a)
elif ([a,b,c].count(b) == 1) :
	print(b)
else :
	print(c)
import fractions
import numpy as np
n,x=map(int,input().split())
li=np.array(input().split(),dtype=np.int64)

li=abs(li-x)

if len(li)==1:
    print(li[0])
else:
    mini=fractions.gcd(li[0],li[1])
    for i in range(1,n):
        gc=math.gcd(mini,li[i])
        mini=min(mini,gc)
    print(mini)
    

### FIXED CODE ###

import fractions
import numpy as np
n,x=map(int,input().split())
li=np.array(input().split(),dtype=np.int64)

li=abs(li-x)

if n==1:
    print(li[0])
else:
    ans=0
    for i in li:
        ans=fractions.gcd(ans,i)
    print(ans)
N = int(input())
D = list(map(int, input().split()))
B = sorted(D)

if B[N/2] == B[(N/2)-1]:
    print(0)
else:
    print(B[N/2]-B[(N/2)-1])

### FIXED CODE ###

N = int(input())
D = list(map(int, input().split()))
B = sorted(D)

if B[int(N/2)] == B[int(N/2)-1]:
    print(0)
else:
    print(B[int(N/2)]-B[int(N/2)-1])
n = input()
a = input()

if (n % 500)<= a:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

n = int(input())
a = int(input())

if (n % 500) <= a:
    print("Yes")
else:
    print("No")
P, n = map(int, input().split())
struct = [list(map(int, input().split())) for x in range(P-1)]
act = [list(map(int, input().split())) for y in range(n)]

A = []


def add_val(action):
    idx = action[0]
    val = action[1]

    A[idx][0] += val

    if A[idx][1]:
        for r in A[idx][1]:
            add_val([r, val])


for a in range(P + 1):
    A.append(list([0, []]))

for z in struct:
    p = z[0]
    p_ = z[1]
    A[p][1].append(p_)

for _ in act:
    add_val(_)


As = []
for _ in range(1, len(A)):
    As.append(A[_][0])

print(*As, sep=' ')




### FIXED CODE ###

from collections import deque

N, Q = map(int, input().split())
edge = [[] for i in range(N)]
ops = []
ans = [0] * N

for _ in range(N - 1):
    a, b = map(int, input().split())
    edge[a - 1].append(b - 1)
    edge[b - 1].append(a - 1)
for _ in range(Q):
    ops.append(tuple(map(int, input().split())))

for op in ops:
    node = op[0] - 1
    pnt = op[1]
    ans[node] += pnt

stack = deque()
stack.append((0, -1))

while stack:
    st = stack.pop()
    node, parent = st[0], st[1]
    children = edge[node]
    for child in children:
        if child == parent:
            continue
        ans[child] += ans[node]
        stack.append((child, node))

print(*ans)
from collections import deque
import sys
#input = sys.stdin.readline

sys.setrecursionlimit(5000)

def get_adj_tiles(v):
  i, j = v
  res = [(i-1, j), (i+1, j), (i, j-1), (i, j+1)]
  return res

def bfs(point):
  visited = []
  que = deque()
  que.append((point, 1))

  while len(que) > 0:
    v, depth = que.popleft()
    visited.append(v)
    adjs = get_adj_tiles(v)
    for a in adjs:
      if field[a[0]][a[1]] == '.' and a not in visited:
        if a == (H, W):
          return depth + 1
        else:
          que.append((a, depth+1))
          if len(que) == 0:
            return 0

          H, W = list(map(int, input().split()))
          field = [['#'] * (W + 2) for _ in range(H + 2)]
          for i in range(H):
            values = list(input())
            field[i+1][1:-1] = values

            number_of_whites = 0
            for i in range(H+2):
              for j in range(W+2):
                if field[i][j] == '.':
                  number_of_whites += 1
                  shortest_path = bfs((1, 1))
                  if shortest_path > 0:
                    print(number_of_whites - shortest_path)
                    else:
                      print(-1)

### FIXED CODE ###

H, W = list(map(int, input().split()))
M = [[-1]*(W+2)]
ans = 0
for _ in range(H):
    s = input()
    ans += s.count('.')
    M.append([-1]+[0 if c=='.' else -1 for c in s]+[-1])
M += [[-1]*(W+2)]

queue = [(1,1)]
M[1][1] = 1
dr = [(+1,0),(-1,0),(0,+1),(0,-1)]
turn = 1
while len(queue)>0:
    turn += 1
    queue_new = []
    for qx, qy in queue:
        for dx, dy in dr:
            x, y = qx+dx, qy+dy
            if M[y][x]==0:
                M[y][x] = turn
                queue_new.append((x,y))
    queue = queue_new

print(ans-M[H][W] if M[H][W]>0 else -1)
from sys import stdin, exit
from math import factorial, gcd
input = stdin.readline
lmi = lambda: list(map(int, input().split()))
mi = lambda: map(int, input().split())
si = lambda: input().strip('\n')
ssi = lambda: input().strip('\n').split()

n = int(input())
arr = lmi()
for i in range(1, n):
    arr[i] = gcd(arr[i], arr[i-1])
print(arr[-1])

### FIXED CODE ###

from sys import stdin
input = stdin.readline
lmi = lambda: list(map(int, input().split()))
mi = lambda: map(int, input().split())
si = lambda: input().strip('\n')
ssi = lambda: input().strip('\n').split()


def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a%b)


n = int(input())
arr = lmi()
for i in range(1, n):
    arr[i] = gcd(arr[i], arr[i-1])
print(arr[n-1])
N = int(input())
a = [int(input()) for i in range(N)]

a.sort()
i = 0
j = N-1
if N <= 2:
    print(abs(a[0] - a[1]))
else:
    ans = a[j] - a[0] + a[j] - a[1]
    i = 0
    j = N-2
    while i < j:
        ans += a[j] - a[i]
        i += 1
        j -= 1
    else:
        if i == j:
            if N // 2 % 2 == 1:
                ans += max(abs(a[j+2]-a[j]), abs(a[j+1]-a[j]))
            else:
                ans += max(abs(a[j]-a[j-1]), abs(a[j]-a[j-2]))
    i = 1
    j = N-1
    ans1 = a[j] - a[0] + a[j-1] - a[0]
    while i < j:
        ans1 += a[j] - a[i]
        i += 1
        j -= 1
    else:
        if i == j:
            if N // 2 % 2 == 0:
                ans1 += max(abs(a[j+2]-a[j]), abs(a[j+1]-a[j]))
            else:
                ans1 += max(abs(a[j]-a[j-1]), abs(a[j]-a[j-2]))
    print(max(ans, ans1))


### FIXED CODE ###

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

a.sort(reverse = True)


keisuu = [0]*n
for i in range(n-1):
    if i % 2 == 0:
        keisuu[i] += 1
        keisuu[i+1] -= 1
    else:
        keisuu[i] -= 1
        keisuu[i+1] += 1
ans = 0
keisuu.sort(reverse = True)
for i in range(n):
    ans += a[i] * keisuu[i]


keisuu = [0]*n
for i in range(n-1):
    if i % 2 == 1:
        keisuu[i] += 1
        keisuu[i+1] -= 1
    else:
        keisuu[i] -= 1
        keisuu[i+1] += 1
keisuu.sort(reverse = True)
ans1 = 0
for i in range(n):
    ans1 += a[i] * keisuu[i]

print(max(ans, ans1))
while True:
	li= list(map(int, input().split())
	li.sort()
	if li==[0,0]
		break
	print(*li)


### FIXED CODE ###

while True:
	x,y=sorted(map(int,input().split()))
	if x==0 and y==0:
		break
	print(x, y)
seq = int(raw_input())

sum = 0
for i in range(1, seq+1, 1):
    if ((i % 3) != 0) & ((i % 5) != 0):
        sum = sum + i
print(sum)

### FIXED CODE ###

seq = int(input())

total = int(0)
for i in range(1, seq+1, 1):
    if ((i % 3) != 0) and ((i % 5) != 0):
        total = total + i
print(total)
N,Q=map(int,input().split())
S=input()
for i in range(N):
  t=S[0:i+1].count("AC")
  A.append(t)
for i in range(Q):
  l,r=map(int,input().split())
  print(A[r-1]-A[l-1])

### FIXED CODE ###

N,Q=map(int,input().split())
S=input()
A=[0]
res=0
for i in range(N):
  if i !=0:
    if S[i-1]=="A" and S[i]=="C":
      res+=1
      A.append(res)
    else:
      A.append(res)
for i in range(Q):
  l,r=map(int,input().split())
  print(A[r-1]-A[l-1])
import collections
N = int(input())
A = sorted(list(map(int, input().split())))
a = collections.Counter(A)
ans = 0
y = 0
for i in a.keys():
    if a[i] >= 2:
        x = y*i
        y = i
    if a[i] >= 4:
        z = i**2
    ans = max(ans, x, z)
print(ans)

### FIXED CODE ###

import collections
N = int(input())
A = list(map(int, input().split()))
a = collections.Counter(A)
ans = [0, 0]
for i in a.keys():
    if a[i] >= 2:
        ans.append(i)
    if a[i] >= 4:
        ans.append(i)
ans.sort()
print(ans[-1]*ans[-2])
import fractions
n,m=map(int,input().split())
a=list(map(int,input().split()))
#print(a)
for i in range(n):
    a[i]=a[i]//2
f2=1
for i in range(n):
    f=fractions.gcd(f2,a[i])
    f2=a[i]*f2//f
#print(f2)
ans=0
for i in range(n):
    if f2/a[i]%2!=1:
        print(ans)
        break
else:
    ans=m//f2
    print((ans+1)//2)

### FIXED CODE ###

import fractions
from functools import reduce
n,m=map(int,input().split())
a=list(map(int,input().split()))
for i in range(n):
    a[i]=a[i]//2
def lcm_base(x,y):
    return (x*y)//fractions.gcd(x,y)
def lcm_list(numbers):
    return reduce(lcm_base,numbers,1)
f2=lcm_list(a)

ans=0
for i in range(n):
    if f2//a[i]%2!=1:
        print(ans)
        break
else:
    ans=m//f2
    print((ans+1)//2)
n = int(input())
d = [int(input()) for i in range(n)]
s = 0
for i in range(n):
    for j in range(n):
        if i != j:
            s += d[i] * d[j]
print(s/2)

### FIXED CODE ###

n = int(input())
d = list(map(int, input().split()))
s = 0
for i in range(n):
    for j in range(n):
        if i != j:
            s += d[i] * d[j]
print(int(s/2))
import numpy as np
n,m = map(int,input().split())

pyl = []
pyl2 = [[] for i in range(n)]    
for _ in range(m):
    p,y = map(int,input().split())
    pyl.append((p,y))
    pyl2[p-1].append(y)
    
argsortpyl = []
for p in pyl2:
    argsortpyl.append(list(np.argsort(np.array(p))))
    
for p,y in pyl:
    x = argsortpyl[p-1].pop(0)
    print(str(p).zfill(6) + str(x+1).zfill(6))

### FIXED CODE ###

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

pyl = []
pyl2 = [[] for i in range(n)]    
for i in range(m):
    p,y = map(int,input().split())
    pyl.append((p,y))
    pyl2[p-1].append((y,i))
    
argsortpyl = []
for p in pyl2:
    argsortpyl.append(sorted(p))
    

ansl = ["" for i in range(m)]

for idx, py in enumerate(argsortpyl):
    for ud,(y,i) in enumerate(py):
        ansl[i] = (idx+1, ud+1)
        
for x,y in ansl:
    print(str(x).zfill(6) + str(y).zfill(6))
N, M = list(map(int, input().split()))

MOD = 10**9+7

class Comb:
    def __init__(self, N):
        self.fac = [1] * (N+1)
        for i in range(2, N+1): self.fac[i] = self.fac[i-1] * i % MOD

    def pow(self, a, b):
        res = 1
        while b:
            if b & 1: res = res * a % MOD
            a = a**2 % MOD
            b >>= 1
        return res

    def comb(self, n, r):
        if r < 0 or r > n: return 0
        return (self.fac[n] * self.pow(self.fac[r], MOD-2)) % MOD * self.pow(self.fac[n-r], MOD-2) % MOD

    def permutation(self, n, r):
        if r == 0: return 1
        return self.fac[n] * self.pow(self.fac[n-r], MOD-2) % MOD

from collections import *
def get_prime(n):
    c = Counter()

    while not n % 2:
        c[2] += 1
        n //= 2
    i = 3

    while i**2 <= n:
        while not n % i:
            c[i] += 1
            n //= i
        i += 2

    if n > 1: 
        c[n] += 1

    return c

prime = get_prime(M)
comb = Comb(N+max([m for m in prime.values()]))

ans = 1

for n in prime.values():
    ans = ans * comb.comb(N+n-1, n) % MOD
print(ans % MOD)

### FIXED CODE ###

import sys
input = sys.stdin.readline

from collections import *

def prime_fact(n):
    prime = Counter()
    m = 0

    while not n % 2: 
        prime[2] += 1
        n //= 2
        m += 1

    x = 3
    while x**2 <= n: 
        c = 0
        while not n % x: 
            prime[x] += 1
            n //= x
            c += 1
        m = max(m, c)
        x += 2

    if n > 1: prime[n] += 1

    return prime, m

MOD = 10**9+7

class Comb:
    def __init__(self, N):
        self.fac = [1] * (N+5)
        for i in range(2, N+5): self.fac[i] = self.fac[i-1] * i % MOD

    def pow(self, a, b):
        res = 1
        while b:
            if b & 1: res = res * a % MOD
            a = a**2 % MOD
            b >>= 1
        return res

    def comb(self, n, r):
        if r < 0 or r > n: return 0
        return (self.fac[n] * self.pow(self.fac[r], MOD-2)) % MOD * self.pow(self.fac[n-r], MOD-2) % MOD

def main():
    N, M = list(map(int, input().split()))
    prime, m = prime_fact(M)

    comb = Comb(N-1+m)
    ans = 1

    for v in prime.values():
        ans = ans * comb.comb(N-1+v, v) % MOD

    print(ans)
    
if __name__ == '__main__':
    main()
N,W = map(int,input().split())
dp = [0]*(W+1)
for i in range(N):
    w,v = map(int,input().split())
    for j in range(W-w+1)[::-1]:
        dp[j+w] = max(dp[j+w],dp[j] + v)
print(max(dp))


### FIXED CODE ###

N,W = map(int,input().split())
dp = [0]+[W+1]*(N*10**3)
for i in range(N):
    w,v = map(int,input().split())
    for j in range(N*10**3+1-v)[::-1]:
        dp[j+v] = min(dp[j+v],dp[j]+w)
for i in range(N*10**3+1)[::-1]:
    if dp[i]<=W:
        print(i)
        exit()
book = input()
if book % 10 == 0 or if book % 10 == 1 or if book % 10 == 6 or if book % 10 == 8 :
	print(pon)
elif book % 10 == 2 or book % 10 == 4 or book % 10 == 5 or book % 10 == 7 or book % 10 == 9:
	print(hon)
elif book % 10 == 3 :
	print(bon)

### FIXED CODE ###

book = int(input())
if book % 10 == 0 or book % 10 == 1 or book % 10 == 6 or book % 10 == 8 :
	print('pon')
elif book % 10 == 2 or book % 10 == 4 or book % 10 == 5 or book % 10 == 7 or book % 10 == 9:
	print('hon')
elif book % 10 == 3 :
	print('bon')
N=int(input());AB=[list(map(int,input().split())) for _ in range(1,N)]
nd=[0 for _ in range(N)]
table = [[] for _ in range(N)]
for a,b in AB:
  table[a-1].append(b)
  nd[a-1]+=1
  nd[b-1]+=1

for _,li in table:
  sort(li)

K=max(nd)
print(K)
co=[0 for _ in range(N)]
for x,li in enumerate(table):
  c=[i for i in range(1,K+1) if i != co[x]]
  for b,y in zip(li,c):
    co[b-1]=y
    print(y)


### FIXED CODE ###

import sys

input = sys.stdin.readline
N=int(input());AB=[tuple(map(int,input().split())) for _ in range(1,N)]

co=[0 for _ in range(N)]
prev=0
color=1
for a,b in sorted(AB):
  if prev!=a:
    color=1
  if co[a-1]==color:
    color+=1
  co[b-1]=color
  prev=a
  color+=1

print(max(co))
for _,b in AB:
  print(co[b-1])
r,g,b = map(int,input().split())
print("YES" if 100*r+10*g+b%4=0 else("NO")

### FIXED CODE ###

r,g,b = map(int,input().split())
print("YES" if (100*r+10*g+b)%4==0 else("NO"))
import sys,math,bisect
input = sys.stdin.readline

mod = 1000000007
eps = 0.001

n = int(input())

ab = []
ang = []
for i in range(n):
    a,b = map(int,input().split())
    ab.append((a,b))
    if a == 0:
        ang.append((90.0,i))
    else:
        ang.append((math.degrees(math.atan(b/a)),i))
ang.sort()

res = 1
used = [False]*n


rest = n

for i in range(n):
    e,idx = ang[i]
    if used[idx]:
        continue
    used[idx] = True
    
    cnt = 1
    k = idx + 1
    while k < n:
        if abs(e-ang[k][0]) <= eps:
            p = ang[k][1]
            if ab[p][0]*ab[idx][1] == ab[p][1]*ab[idx][0]:
                cnt += 1
                used[ang[k][1]] = True
            k += 1
        else:
            break
    
    tmp = pow(2,cnt,mod)

    cnt2 = 0

    ok = n-1
    ng = idx
    while ok-ng > 1:
        mid = (ok+ng)//2
        if ang[mid][0] >= e+90-eps:
            ok = mid
        else:
            ng = mid
    k = ok
    while k < n:
        if abs(e+90-ang[k][0]) <= eps:
            p = ang[k][1]
            if ab[p][0]*ab[idx][0] + ab[p][1]*ab[idx][1] == 0:
                cnt2 += 1
                used[ang[k][1]] = True
            k += 1
        else:
            break

    if cnt2 != 0:
        res = res*(tmp + pow(2,cnt2,mod)-1)%mod
        rest -= cnt+cnt2

res = res*pow(2,rest,mod)%mod - 1
print(res)





### FIXED CODE ###

import sys,math
input = sys.stdin.buffer.readline

mod = 1000000007
n = int(input())

ab = []
ang = dict()
rev = dict()
dg = 10**20
zero = 0

for i in range(n):
    a,b = map(int,input().split())
    if a == 0 and b == 0:
        zero += 1
    elif a == 0:
        if 1 in ang:
            ang[1] += 1
        else:
            ang[1] = 1
    elif b == 0:
        if 1 in rev:
            rev[1] += 1
        else:
            rev[1] = 1
    elif a*b > 0:
        if a < 0 and b < 0:
            a,b = -a,-b
        g = math.gcd(a,b)
        a,b = a//g,b//g

        if a*dg + b in ang:
            ang[a*dg + b] += 1
        else:
            ang[a*dg + b] = 1
    else:
        a,b = abs(a),abs(b)
        g = math.gcd(a,b)
        a,b = a//g,b//g

        if b*dg + a in rev:
            rev[b*dg + a] += 1
        else:
            rev[b*dg + a] = 1

rest = n - zero

res = 1

for e in ang:
    if e in rev:
        res = res*(pow(2,ang[e],mod) + pow(2,rev[e],mod) - 1)%mod
        rest -= ang[e] + rev[e]

res = res*pow(2,rest,mod)%mod - 1 + zero

print(res%mod)
N=int(input())
a=list(map(int,input().split()))
cnt=0

for i in range(int(len(a)/2)+1):
    if a[2*i]%2==1:
        cnt+=1

print(cnt)


### FIXED CODE ###

N=int(input())
a=list(map(int,input().split()))
cnt=0

for i in range(0,len(a),2):
    if a[i]%2==1:
        cnt+=1

print(cnt)
import sys
N = int(sys.stdin.readline())

 if N % 2 == 0:
    print(0.5)
else:
    print(N / (2*N + 1))

### FIXED CODE ###

import sys

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

if N % 2 == 0:
  a = 1 / 2
else:
  a = (N+1) / (2 * N)

print('%.10f' %a)
import math
from functools import reduce

def gcd(*numbers):
    return reduce(math.gcd, numbers)

def gcd_list(numbers):
    return reduce(math.gcd, numbers)

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

ans = 0

for i in range(N):
    a = A.pop(0)
    p = gcd_list(A)
    if p > ans:
        ans = p
    A.append(a)
print(ans)
    

### FIXED CODE ###

# -*- coding: utf-8 -*-
"""
Created on Sat Jun 29 20:51:40 2019

@author: makigon
"""

import fractions
from functools import reduce
 
def gcd_list(numbers):
    return reduce(fractions.gcd, numbers)
 
N = int(input())
a = list(map(int,input().split()))
ans = 0

t_left = [0 for i in range(N)]
t_right = [0 for i in range(N)]

t_left[0] = a[0]
t_left[1] = fractions.gcd(a[0],a[1])

for i in range(2,N):
    t_left[i] = fractions.gcd(t_left[i-1],a[i])

t_right[N-1] = a[N-1]
t_right[N-2] = fractions.gcd(a[N-1],a[N-2])

for j in range(N-3,0,-1):
    t_right[j] = fractions.gcd(t_right[j+1],a[j])
    

for i in range(0,N-2):
    tmp = fractions.gcd(t_left[i],t_right[i+2])
    if tmp > ans:
        ans = tmp
    
print(max(ans,t_right[1],t_left[N-2]))
from math import factorial

n, a, b = map(int, input().split())
v = list(map(int, input().split()))
v.sort(reverse=True)

n1 = v.count(v[a - 1])
n2 = v[:a].count(v[:a][a - 1])

print(sum(v[:a]) / a)
if len(set(v[:a])) != 1:
	if n1 == n2:
		print(1)
	else:
		print(int(factorial(n1) / (factorial(n2) * factorial(n1 - n2))))
else:
	ans = 0
	if n1 == 1:
		print(1)
	else:
		for i in range(a, min(n1, b + 1)):
			if 
			ans += int(factorial(n1) / (factorial(i) * factorial(n1 - i)))
		print(int(ans))

### FIXED CODE ###

from math import factorial

n, a, b = map(int, input().split())
v = list(map(int, input().split()))
v.sort(reverse=True)

n1 = v.count(v[a - 1])
n2 = v[:a].count(v[:a][a - 1])

print(sum(v[:a]) / a)
if len(set(v[:a])) != 1:
	if n1 == n2:
		print(1)
	else:
		print(int(factorial(n1) / (factorial(n2) * factorial(n1 - n2))))
else:
	ans = 0
	if n1 == 1:
		print(1)
	else:
		for i in range(a, min(n1 + 1, b + 1)):
			ans += int(factorial(n1) / (factorial(i) * factorial(n1 - i)))
		print(int(ans))
n = int(input())
m = 1
ans = 0
while m <= int(sqrt(n)):
    if n % m == 0 and m < n // m:
        ans += n // i - 1
    m += 1
print(ans)


### FIXED CODE ###

n = int(input())
ans = 0
for m in range(1, int(n**0.5)+1):
    if n%m == 0 and m < n//m-1:
        ans += n//m -1
print(ans)
"""
while m <= int(n**0.5):
    if n % m == 0 and m < n // m:
        ans += n // m - 1
    m += 1
print(ans)
"""
n = int(input)
p = list(map(int, input().split()))
v = sorted(p)
cou=0
for i in range(len(p)):
    if not p[i] == v[i]:
        cou+=1

if cou <= 2:
    print('YES')
else:
    print('NO')

### FIXED CODE ###

n = int(input())
p = list(map(int, input().split()))
 
q = sorted(p)
cou = 0
for i in range(n):
    if p[i] != q[i]:
        cou += 1
 
if cou <= 2:
    print("YES")
else:
    print("NO")
a

### FIXED CODE ###

def g_c_d(x, y):
    if x == 0:
        return y
    elif y == 0:
        return x
    else:
        return g_c_d(y, x % y)


a = int(input())
b = list(map(int, input().split()))
b.append(0)
b.insert(0, 0)
c = [0]*(len(b))
d = [0]*(len(b))
for i in range(1, len(b)):
    c[i] = (g_c_d(b[i], c[i-1]))
    d[-i-1] = (g_c_d(b[-i-1], d[-i]))
e = 0
for i in range(0, len(c)-2):
    e = max(g_c_d(c[i], d[i+2]), e)
print(e)
def smaller(x, y):
	if x < y: return x
	return y

N = int(raw_input())
A = map(int, raw_input().split())
A.sort()
min1 = A[0]
for i in range(1, N):
	if A[i]%min != 0 and A[i]%min < min: min = A[i]%min
min2 = A[-1]
for i in range(1, N):
	if min2%A[i] == 0: min2 = A[i]
	else: min2 = min2%A[i] 
print smaller(min1, min2)

### FIXED CODE ###

def euc(x, y):
	if y == 0: return x
	return euc(y, x%y)

N = int(input())
A = list(map(int, input().split()))
ans = A[0]
for i in range(1, N):
	ans = euc(ans, A[i])
print(ans)
n = int(raw_input())
p = [0 for i in range(0, 101)]
m = [[0 for i in range(0, 101)] for j in range(0, 101)]
for i in range(1, n+1):
????????p[i-1], p[i] = map(int, raw_input().split())
??????????
for l in range(2, n+1):
????????for i in range(1, n-l+1+1):
????????????????j = i+l-1
????????????????m[i][j] = float("inf")
????????????????for k in range(i, j):
????????????????????????m[i][j] = min(m[i][j], m[i][k] + m[k+1][j] + p[i-1] * p[k] * p[j])
??
print m[1][n]

### FIXED CODE ###

n = int(raw_input())
p = [0 for i in range(0, 101)]
m = [[0 for i in range(0, 101)] for j in range(0, 101)]
for i in range(1, n+1):
    p[i-1], p[i] = map(int, raw_input().split())
     
for l in range(2, n+1):
    for i in range(1, n-l+2):
        j = i+l-1
        m[i][j] = float("inf")
        for k in range(i, j):
            m[i][j] = min(m[i][j], m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j])
 
print m[1][n]
x, y = input().split()
x = int(x)
y = int(y.replace(".", ""))
print((x*y)//100)

### FIXED CODE ###

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

A.sort()
ans = 1
flag=False
for a in A:
  ans *= a
  if ans > 1e18:
    flag=True
    break
if flag:
  print(-1)
else:
  print(ans)