Harryxun/stf_run huggingface dataset:
a,b,c,d,e,f=map(int,input().split())
w_m=f//(100+e)*100
s_m=f//(100+e)*e
w=w_m//(100*a)*(100*a)
s=s_m//c*c
wn=w_m//(100*b)
sc=s_m//c
sd=s_m//d
noudo=0
answ=0
anss=0
for i in range(wn+1):
    for j in range(sc+1):
        for k in range((s_m-j*c)//d+1):
            s=j*c+k*d
            if (noudo<s/(s+w)) and (s/(s+w)<=e/(100+e)):
                noudo=s/(s+w)
                answ=w
                anss=s
    w+=b*100
    while w<=w_m:
        w-=a*100

print(answ+anss,anss)

### FIXED CODE ###

a,b,c,d,e,f=map(int,input().split())
w_m=int((f*100/(100+e)))//100*100
s_m=f*e//(100+e)
answ=100*a
anss=0
for i in range(w_m//(a*100)+1):
    for j in range((w_m-i*a*100)//(b*100)+1):
        w=(i*a+j*b)*100
        if i==0 and j==0:
            w=min(100*a,100*b)
            s_m=f-w
        for k in range(s_m//c+1):
            for l in range((s_m-k*c)//d+1):
                s=k*c+l*d
                if (anss*(s+w)<s*(anss+answ)) and (s*(100+e)<=e*(s+w)):
                    answ=w
                    anss=s
print(answ+anss,anss)
N, *s = map(open(0).read().split())
for v in ('AC', 'WA', 'TLE', 'RE'):
    print('{} x {}'.format(v, s.count(v)))


### FIXED CODE ###

N = int(input())
s = [input() for i in range(N)]
for v in ('AC', 'WA', 'TLE', 'RE'):
    print('{} x {}'.format(v, s.count(v)))
import sys
input=sys.stdin.readline

def BellmanFord(Edges,num_v,start,goal):
    inf=float('inf')
    Dist=[inf]*num_v
    Dist[start]=0
    for _ in range(num_v):
        for fr,to,cost in Edges:
            if Dist[fr]!=inf and Dist[to]>Dist[fr]+cost:
                Dist[to]=Dist[fr]+cost
    d=Dist[goal]
    for _ in range(num_v):
        for fr,to,cost in Edges:
            if Dist[fr]!=inf and Dist[to]>Dist[fr]+cost:
                Dist[to]=-inf
    if d!=Dist[goal]:
        return -inf
    return d

n,m,p=map(int,input().split())
Edges=[]
for _ in range(m):
    a,b,c=map(int,input().split())
    a-=1; b-=1
    Edges.append((a,b,-(c-p)))
d=BellmanFord(Edges,n,0,n-1)
print(-1 if d==-float('inf') else max(0,-d[-1]))

### FIXED CODE ###

import sys
input=sys.stdin.readline

def BellmanFord(Edges,num_v,source):
    inf=float('inf')
    dist=[inf for _ in range(num_v)]
    dist[source]=0
    for i in range(num_v):
        for edge in Edges:
            if edge[0]!=inf and dist[edge[1]]>dist[edge[0]]+edge[2]:
                dist[edge[1]]=dist[edge[0]]+edge[2]
                if i==num_v-1:
                    before_dist=dist[num_v-1]
                    for i in range(num_v):
                        for edge in Edges:
                            if edge[0]!=inf and dist[edge[1]] > dist[edge[0]]+edge[2]:
                                dist[edge[1]]=dist[edge[0]]+edge[2]
                    if before_dist!=dist[num_v-1]:
                        return -1
    return dist

n,m,p=map(int,input().split())
Edges=[]
for _ in range(m):
    a,b,c=map(int,input().split())
    a-=1; b-=1
    Edges.append((a,b,-(c-p)))
d=BellmanFord(Edges,n,0)
print(-1 if d==-1 else max(0,-d[-1]))
K= int(input())
if K%2==0:
  print((K/2)**2)
else:
  print(K//2)*(K//2+1))

### FIXED CODE ###

K= int(input())
if K%2==0:
  print((K//2)**2)
else:
  print((K//2)*(K//2+1))
a=int(input())
v=int(input())
b=int(input())
w=int(input())
t=int(input())

if a<b:
  if b+wt<=a+vt:
    print('YES')
  else:
    print('NO')
if a>b:
  if a-vt<=b-wt:
    print('YES')
  else:
    print('NO')

### FIXED CODE ###

a,v=map(int, input().split())
b,w=map(int, input().split())
t=int(input())
 
if a<b:
  if b+w*t<=a+v*t:
    print('YES')
  else:
    print('NO')
if a>b:
  if a-v*t<=b-w*t:
    print('YES')
  else:
    print('NO')
N,X = map(int,raw_input().split())
m = sorted([input() for m in range(N)])
X -= sum(m)
print ans = N + X / m[0]

### FIXED CODE ###

N,X = map(int,raw_input().split())
m = sorted([input() for m in range(N)])
X -= sum(m)
ans = N + X / m[0]
print ans
n = (int(input()))
li = []
for i in range(1,n+1):
    if i%2 == 0:
        li.append(i)

li = [bin(x) for x in li]
li = li[::-1]
for i in range(len(li)):
    if li[i].count(str(1)) == 1:
        a=((li[i].count(str(0)) -1))
        break
print(2**a)

### FIXED CODE ###

n = (int(input()))
if n ==1:
    print(1)
li = []
for i in range(1,n+1):
    if i%2 == 0:
        li.append(i)

li = [bin(x) for x in li]
li = li[::-1]
for i in range(len(li)):
    
    if li[i].count(str(1)) == 1:
        a=((li[i].count(str(0)) -1))
        print(2**a)
        break
s = input()
q = int(input)
rev = False
for i in range(q):
  inp = input()
  if int(inp[0]) == 1:
    rev = not rev
  else:
    t, f, c = inp.split()
    if (int(f) == 1 and rev) or (int(f) == 2 and not rev):
      s += c
    else:
      s = c + s
print(reversed(s) if rev else s)

### FIXED CODE ###

s = input()
q = int(input())
rev = False
pre = ''
for i in range(q):
  inp = input()
  if int(inp[0]) == 1:
    rev = not rev
  else:
    t, f, c = inp.split()
    if (int(f) == 1 and rev) or (int(f) == 2 and not rev):
      s += c
    else:
      pre += c
print(s[::-1] + pre if rev else pre[::-1] + s)
a, b, c = map(int  input().split())

if a <= c and c <= b:
    print("Yes")
else:
    print("No")


### FIXED CODE ###

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

if a <= c and c <= b:
    print("Yes")
else:
    print("No")
def resolve():
    _ = int(input())
    targets = list(map(int, input().split()))

    targets = [x for x in set(targets) if targets.count(x) == 1]
    if len(targets) == 0:
        print(0)
        return
    targets.sort()
    targets = deque(targets)

    ans = []

    while len(targets) > 0:
        target = targets.popleft()
        ans.append(target)
        removeList = []
        for x in targets:
            if x % target == 0:
                removeList.append(x)
        for x in removeList:
            targets.remove(x)

    print(len(ans))

resolve()

### FIXED CODE ###

#!/usr/bin/env python3
import sys


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


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


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


def main():
    N = II()
    A = LI()
    A.sort()
    MAX = A[-1]+1
    All = [0 for i in range(MAX)]

    setA = set(A)
    for i in A:
        k = i
        All[k] += 1
        k += i
        if All[i] == 2:
            continue
        while k < MAX and i in setA:
            All[k] += 1
            k += i

    ans = 0
    for i in range(1, MAX):
        if All[i] == 1 and i in setA:
            ans += 1

    print(ans)

    # oj t -c "pypy3 main.py"
    # acc s main.py -- --guess-python-interpreter pypy
main()
#!/usr/bin/env python3
import sys


def solve(N: int, A: "List[int]"):
    result_list = []
    for i in range(1, N + 1):
        result_list.append(str(A.index(i) + 1))
    print(" ".join(result_list))
    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


def solve(N: int):
    count = 0
    for i in range(1, N + 1):
        if i % 2 != 0:
            count += 1
        else:
            pass

    result = count / N

    print(result)

    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
    solve(N)


if __name__ == "__main__":
    main()
import sys
N,M = map(int,input().split())
intact = [True for _ in range(N)]
dp = [0 for _ in range(N+1)]
MOD = 1000000007
for i in range(M):
  a = int(input())
  if N == 1:
    print(1)
    sys.exit(0)
  intact[a] = False
dp[0] = 1
if (intact[1]):
  dp[1] = 1
for i in range(2,N+1):
  if intact[i-2]:
    dp[i] += dp[i-2]
  if intact[i-1]:
    dp[i] += dp[i-1]
  dp[i] %= MOD
print(dp[N])

### FIXED CODE ###

import sys
N,M = map(int,input().split())
intact = [True for _ in range(N)]
dp = [0 for _ in range(N+1)]
MOD = 1000000007
for i in range(M):
  a = int(input())
  intact[a] = False
if N == 1:
  print(1)
  sys.exit(0)
dp[0] = 1
if (intact[1]):
  dp[1] = 1
for i in range(2,N+1):
  if intact[i-2]:
    dp[i] += dp[i-2]
  if intact[i-1]:
    dp[i] += dp[i-1]
  dp[i] %= MOD
print(dp[N])
def counter(a):
  count = 0 
  while a%2 ==0:
    a /= 2
    count += 1
  return count
s = list(map(int,input().split()))
print(min(list(map(counter,s)))

     


### FIXED CODE ###

def counter(a):
  count = 0 
  while a%2 ==0:
    a /= 2
    count += 1
  return count
N = int(input())
s = [int(n) for n in input().split()]
print(min([counter(a) for a in s]))
import sys, math, collections, heapq, itertools
  
def solve():
    file = sys.stdin.readline #single: int(file()), line: map(int, file().split())
    INF = 10 ** 25
    mod = 7 + 10 ** 9
    N = int(file())
    A = [int(a) for a in file().split()]
    A.sort()
    ans = 0
    out = []
    if N == 2:
        ans = A[1] - A[0]
        out = [A[1], A[0]]
    elif A[N-2] <= 0:
        ans = A[N-1] - A[N-2]
        out.append([A[N-1], A[N-2]])
        for i in range(N-2):
            out.append([ans, A[i]])
            ans -= A[i]
    elif A[1] >= 0:
        ans = A[0] - A[1]
        out.append([A[0], A[1]])
        for i in range(2, N-1):
            out.append([ans, A[i]])
        out.append([A[N-1], ans])
        ans = A[N-1] - ans
    else:
        for i in range(1, N-1):
            if A[i] >= 0:
                start = i-1
                break
        ans = A[start] - A[start + 1]
        out.append([A[start], A[N-1]])
        if start + 2 < N - 1:
            for i in range(start + 2, N - 1):
                out.append([ans, A[i]])
                ans -= A[i]
        out.append([A[N-1], ans])
        ans = A[N-1] - ans
        for i in range(start):
            out.append([ans, A[i]])
            ans -= A[i]

    print(ans)
    for k in out:
        print(" ".join(map(str, k)))

    return 0
  
if __name__ == "__main__":
    solve()

### FIXED CODE ###

import sys, math, collections, heapq, itertools
from bisect import bisect_left
  
def solve():
    file = sys.stdin.readline #single: int(file()), line: map(int, file().split())
    INF = 10 ** 25
    mod = 7 + 10 ** 9
    N = int(file())
    A = [int(a) for a in file().split()]
    A.sort()
    ans = 0
    out = []
    if N == 2:
        ans = A[1] - A[0]
        out = [[A[1], A[0]]]
    else:
        plus = bisect_left(A, 0)
        if plus == 0:
            ans = A[0]
            for i in range(1, N-1):
                out.append([ans, A[i]])
                ans -= A[i]
            out.append([A[N-1], ans])
            ans = A[N-1] - ans
        elif plus < N:
            ans = A[0]
            for i in range(plus, N - 1):
                out.append([ans, A[i]])
                ans -= A[i]
            out.append([A[N-1], ans])
            ans = A[N-1] - ans
            for i in range(1, plus):
                out.append([ans, A[i]])
                ans -= A[i]
        else:
            ans = A[N-1]
            for i in range(N-1):
                out.append([ans, A[i]])
                ans -= A[i]

    print(ans)
    for k in out:
        print(" ".join(map(str, k)))


    return 0
  
if __name__ == "__main__":
    solve()
n=int(input())
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())

mi=min(a,b,c,d,e)
if n%mi != 0
    print((n//mi)+1+4)
else:
    print((n//mi)+4)

### FIXED CODE ###

n=int(input())
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())

mi=min(a,b,c,d,e)
if n%mi != 0:
    print((n//mi)+1+4)
else:
    print((n//mi)+4)
a = input()
b = list(map(int,input()split()))
if 'Y' in b:
    print('Four')
else:
    print('Three')

### FIXED CODE ###

a = input()
b = list(input().split())
if 'Y' in b:
    print('Four')
else:
    print('Three')
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7


lim = 2*10**5   #必要そうな階乗の限界を入力

#階乗#
fact = [1] * (lim+1)
for n in range(1, lim+1):
	fact[n] = n * fact[n-1] % mod

#階乗の逆元#
fact_inv = [1]*(lim+1)
fact_inv[lim] = pow(fact[lim], mod-2, mod)
for n in range(lim, 0, -1):
	fact_inv[n-1] = n*fact_inv[n]%mod

def C(n, r):
	return (fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod


H, W, A, B = MAP()

ans = 0
for n in range(B, W):
	way = C(H-A-1+n, n)*C(W-n-1+A-1, A-1)%mod
	ans = (ans+way)%mod

print(ans)

### FIXED CODE ###

import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

lim = 2*10**6
fact = [1]*(lim+1)
for n in range(1, lim+1):
	fact[n] = n*fact[n-1]%mod

fact_inv = [1]*(lim+1)
fact_inv[lim] = pow(fact[lim], mod-2, mod)
for n in range(lim, 0, -1):
	fact_inv[n-1] = n*fact_inv[n]%mod

def C(n, r):
	return (fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod

H, W, A, B = MAP()

ans = 0
for n in range(B, W):
	way = C(H-A-1+n, n)*C(W-n-1+A-1, A-1)%mod
	ans = (ans+way)%mod

print(ans)
numOfK = input()
numOfN = input()

if numOfK * 500 > numOfN:
  print("Yes")
else:
  print("No")

### FIXED CODE ###

[K, X] = [int(x) for x in input().split()]
if K * 500 >= X:
    print('Yes')
else:
    print('No')
from sys import stdin
S = stdin.readline().rstrip()
n = len(S)
def dfs(i, f):
    if i = n-1:
        return sum(list(map(int, f.split('+'))))
    return dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' s[i-1])
print(dfs(0, S[0]))


### FIXED CODE ###

from sys import stdin
S = stdin.readline().rstrip()
n = len(S)
def dfs(i, f):
    if i == n-1:
        return sum(list(map(int, f.split('+'))))
    return dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' + S[i+1])
print(dfs(0, S[0]))
import numpy as np
n = int(input())
print(sum(np.arange(n)))

### FIXED CODE ###

import numpy as np
n = int(input())
print(n * (n-1) // 2)
N = int(input())
flg = 'No'
for i in range(1,10):
  for j in range(1, 10):
    if N == i*j:
      flg = 'Yes'
print(flg)

### FIXED CODE ###

A, B = map(int, input().split())
print(A*B if 1 <= A <= 9 and 1 <= B <= 9 else '-1')
from bisect import bisect_right
p = 10**9+7
N,M = map(int,input().split())
A = list(map(int,input().split()))
CA = {}
for i in range(N):
    if A[i] not in CA:
        CA[A[i]] = 0
    CA[A[i]] += 1
indA = [0 for _ in range(N*M+1)]
for i in range(N):
    indA[A[i]] = 1
A1 = sorted(A[:])
B = list(map(int,input().split()))
CB = {}
for j in range(M):
    if B[j] not in CB:
        CB[B[j]] = 0
    CB[B[j]] += 1
indB = [0 for _ in range(N*M+1)]
for j in range(M):
    indB[B[j]] = 1
B1 = sorted(B[:])
flag = 0
if CA[N*M]!=1:flag=1
if CB[N*M]!=1:flag=1
for a in CA:
    if CA[a]>1:
        flag = 1
        break
for b in CB:
    if CB[b]>1:
        flag = 1
        break
if flag==1:
    print(0)
else:
    dp = [0 for _ in range(N*M+1)]
    dp[N*M] = 1
    for k in range(N*M-1,0,-1):
        if indA[k]==1 and indB[k]==1:
            dp[k] = dp[k+1]
        elif indA[k]==1 and indB[k]==0:
            cnt = bisect_right(B1,k)
            cnt = M-cnt
            dp[k] = (dp[k+1]*cnt)%p
        elif indA[k]==0 and indB[k]==1:
            cnt = bisect_right(A1,k)
            cnt = N-cnt
            dp[k] = (dp[k+1]*cnt)%p
        else:
            cnt1 = bisect_right(A1,k)
            cnt1 = N-cnt1
            cnt2 = bisect_right(B1,k)
            cnt2 = M-cnt2
            cnt = cnt1*cnt2-(N*M-k)
            dp[k] = (dp[k+1]*cnt)%p
    print(dp[1])

### FIXED CODE ###

from bisect import bisect_right
p = 10**9+7
N,M = map(int,input().split())
A = list(map(int,input().split()))
CA = {}
for i in range(N):
    if A[i] not in CA:
        CA[A[i]] = 0
    CA[A[i]] += 1
indA = [0 for _ in range(N*M+1)]
for i in range(N):
    indA[A[i]] = 1
A1 = sorted(A[:])
B = list(map(int,input().split()))
CB = {}
for j in range(M):
    if B[j] not in CB:
        CB[B[j]] = 0
    CB[B[j]] += 1
indB = [0 for _ in range(N*M+1)]
for j in range(M):
    indB[B[j]] = 1
B1 = sorted(B[:])
flag = 0
if N*M not in CA or CA[N*M]!=1:flag=1
if N*M not in CB or CB[N*M]!=1:flag=1
for a in CA:
    if CA[a]>1:
        flag = 1
        break
for b in CB:
    if CB[b]>1:
        flag = 1
        break
if flag==1:
    print(0)
else:
    dp = [0 for _ in range(N*M+1)]
    dp[N*M] = 1
    for k in range(N*M-1,0,-1):
        if indA[k]==1 and indB[k]==1:
            dp[k] = dp[k+1]
        elif indA[k]==1 and indB[k]==0:
            cnt = bisect_right(B1,k)
            cnt = M-cnt
            dp[k] = (dp[k+1]*cnt)%p
        elif indA[k]==0 and indB[k]==1:
            cnt = bisect_right(A1,k)
            cnt = N-cnt
            dp[k] = (dp[k+1]*cnt)%p
        else:
            cnt1 = bisect_right(A1,k)
            cnt1 = N-cnt1
            cnt2 = bisect_right(B1,k)
            cnt2 = M-cnt2
            cnt = cnt1*cnt2-(N*M-k)
            dp[k] = (dp[k+1]*cnt)%p
    print(dp[1])
def solve(S):
    dp = [0]*(S+1)
    dp[0] = 1
    dp[3] = 1
    MOD = 10**9+7
    for n in range(4, S+1):
        answer = 0
        for c in range(3, n+1):
            #print(n, "c=%d"%c, dp[c])
            answer = (answer + dp[n-c]) % MOD
        dp[n] = answer % MOD
        #print(n, dp[n])
    return dp[S]
#solve(7)
print(solve(int(input())))


### FIXED CODE ###


def solve(S):
    dp = [0]*(2000+1)
    dp[0] = 1
    dp[3] = 1
    MOD = 10**9+7
    for n in range(4, S+1):
        answer = 0
        for c in range(3, n+1):
            #print(n, "c=%d"%c, dp[c])
            answer = (answer + dp[n-c]) % MOD
        dp[n] = answer % MOD
        #print(n, dp[n])
    return dp[S]
#solve(7)
print(solve(int(input())))
def knapsack(n,W):
  if n==0 or W==0 :
    return 0
  elif dp[n][W]!=-1:
    return dp[n][W]
  
  else:
    if wt[n-1]<=W:
      
      dp[n][W]=max(knapsack(n-1,W),p[n-1]+knapsack(n-1,W-wt[n-1]))
      return dp[n][W]
    else:
      dp[n][W]=knapsack(W,n-1)
      return dp[n][W]
    
wt,p=[],[]
n,w=map(int,input().split())
dp=[[-1 for i in range(w+1)]for j in range(n+1)]
for _ in range(n):
    temp_wt,temp_pr=map(int,input().split())
    wt.append(temp_wt)
    p.append(temp_pr)
print(knapsack(n,w))



### FIXED CODE ###

n,W=map(int,input().split())
t = [[-1 for i in range(W + 1)] for j in range(n + 1)] 
  
  
def knapsack(wt, val, W, n):     
  
    # base conditions 
    if n == 0 or W == 0: 
        return 0
    if t[n][W] != -1: 
        return t[n][W] 
  
    # choice diagram code 
    if wt[n-1] <= W: 
        t[n][W] = max(val[n-1] + knapsack(wt, val, W-wt[n-1], n-1),knapsack(wt, val, W, n-1)) 
        return t[n][W] 
    elif wt[n-1] > W: 
        t[n][W] = knapsack(wt, val, W, n-1) 
        return t[n][W] 

weight,profit=[],[]
for _ in range(n):
  w,p=map(int,input().split())
  weight.append(w)
  profit.append(p) 
print(knapsack(weight,profit, W, n))
n=int(input())
if n<=9:
  print(n)
elif n<=99:
  print(9)
elif n<=999:
  print(n-90)
elif n<=9999:
  print(909)
elif n==100000:
  print(90909)
else:
  print(n-9090)


### FIXED CODE ###

a,b,c=map(int,input().split())
if (c+b-a)>0:
  print(c+b-a)
else:
  print('0')
s = input()
s.sorted()
if s.count(s[0]) == s.count(s[-1]):
  print('Yes')
else:
  print('No')


### FIXED CODE ###

s = list(input())
s.sort()
if s[0] == s[1] and s[2] == s[3] and s[0] != s[2]:
  print('Yes')
else:
  print('No')
A,B,C,D = input().split()
count = 0
start = int(A)
finish = int(B)
ite = finish//start
for i in range(ite):
  if i == ite-1:
    nums = list(range(start *i, finish ))
  else:
    nums = list(range(start *i, start*(i+1) ))
  tmp = [x for x in nums if not x%int(C) == 0 and not x%int(D) == 0]
  count += len(tmp)
print(count)


### FIXED CODE ###

import fractions

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)
A,B,C,D = input().split()
A = int(A)-1
s = lcm(int(C),int(D))
#s = int(C)*int(D)
#numac = int(A)//int(C)#10//6 = 1
#numad = int(A)//int(D)#10//8 = 1
#numacd = int(A)//s#10//24 = 0
numa = int(A)//int(C) + int(A)//int(D) - int(A)//s
#numa = 1
#numbc = int(B)//int(C)#40//6 = 6
#numbd = int(B)//int(D)#40//8 = 5
#numbcd = int(B)//s#40//24= 1
numb = int(B)//int(C) + int(B)//int(D) - int(B)//s
#numb = 1
print(int(B)-int(A)-(numb - numa))
import sys

def main(argv):

  #L = int(argv.pop())
  #tree = [int(s) for s in argv]
  n = int(argv[0])
  if n%2 == 0:
    print(n/2)
  else:
    print(int(n/2)+1)

if __name__ == '__main__':
    main(sys.argv[1:])


### FIXED CODE ###

s = input().strip()
s = int(s)

if s%2 == 0:
    print(int(s/2))
else:
    print(int(s/2)+1)
n = input()
if n % 2 == 1:
  print((n // 2) + 1)
else:
  print(n // 2)

### FIXED CODE ###

n = int(input())
if (n % 2) == 1:
  print((n // 2) + 1)
else:
  print(n // 2)
N, M = map(int,input().split())
connections=[]
for _ in range(M):
    connections.append(list(map(int,input().split())))
conditions = list(map(int,input.split()))

ans_cnt = 0
for i in range(2**N):
    condition_cnt = 0
    for j in range(M):

        cnt=0
        for k in connections[j][1:]:
            if (i >> k) & 1):
                cnt += 1
        if (cnt +conditions[j])%2 == 0:
            condition_cnt += 1
    if condition_cnt == M:
        ans_cnt += 1

print(ans_cnt)


### FIXED CODE ###

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

conditions = [list(map(int,input().split())) for _ in range(M)]
p = list(map(int,input().split()))

ans = 0
for i in range(2**N):
    light_cnt = 0
    for condition_idx in range(M):


        switch_num = 0
        for j in range(N):
            if i >> j & 1 and j+1 in conditions[condition_idx][1:]: # つながっているスイッチの押してあるものを数える
                switch_num += 1
        if switch_num%2 == p[condition_idx]:
            light_cnt += 1
    if light_cnt == M:
        ans += 1
print(ans)
import heapq

n, m = map(int,input().split())
joblist = {}
for i in range(n):
    a,b = map(int,input().split())
    if a in joblist:
        joblist[a].append(-1*b)
    else:
        joblist[a] = [-1*b]

kouho = []
 
ans =0
 
for i in range(1,m+1):
    if i in joblist:
        for j in joblist[i]:
            heapq.heappush(kouho,j)
    
    ans += heapq.heappop(kouho)
 
print(-1*ans)

### FIXED CODE ###

import heapq

n, m = map(int,input().split())
joblist = {}
for i in range(n):
    a,b = map(int,input().split())
    if a in joblist:
        joblist[a].append(-1*b)
    else:
        joblist[a] = [-1*b]

kouho = []
 
ans =0
 
for i in range(1,m+1):
    if i in joblist:
        for j in joblist[i]:
            heapq.heappush(kouho,j)
    if kouho:
        ans += heapq.heappop(kouho)
 
print(-1*ans)