Problem:
 Score : 200 points    Problem Statement There are N rectangular plate materials made of special metal called AtCoder Alloy.
The dimensions of the i -th material are A_i \times B_i ( A_i vertically and B_i horizontally).  Takahashi wants a rectangular plate made of AtCoder Alloy whose dimensions are exactly H \times W .
He is trying to obtain such a plate by choosing one of the N materials and cutting it if necessary.
When cutting a material, the cuts must be parallel to one of the sides of the material.
Also, the materials have fixed directions and cannot be rotated.
For example, a 5 \times 3 material cannot be used as a 3 \times 5 plate.  Out of the N materials, how many can produce an H \times W plate if properly cut?      Constraints  1 \leq N \leq 1000  1 \leq H \leq 10^9  1 \leq W \leq 10^9  1 \leq A_i \leq 10^9  1 \leq B_i \leq 10^9         Input Input is given from Standard Input in the following format:  N  H  W  A_1  B_1  A_2  B_2  :  A_N  B_N       Output Print the answer.        Sample Input 1 3 5 2
10 3
5 2
2 5      Sample Output 1 2  Takahashi wants a 5 \times 2 plate.   The dimensions of the first material are 10 \times 3 . We can obtain a 5 \times 2 plate by properly cutting it.  The dimensions of the second material are 5 \times 2 . We can obtain a 5 \times 2 plate without cutting it.  The dimensions of the third material are 2 \times 5 . We cannot obtain a 5 \times 2 plate, whatever cuts are made. Note that the material cannot be rotated and used as a 5 \times 2 plate.        Sample Input 2 10 587586158 185430194
894597290 708587790
680395892 306946994
590262034 785368612
922328576 106880540
847058850 326169610
936315062 193149191
702035777 223363392
11672949 146832978
779291680 334178158
615808191 701464268      Sample Output 2 8

Solution (Python):






import sys
input = sys.stdin.readline

import math

import bisect
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache






MOD = 10**9+7
INF = float('inf')






def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(input()) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]


def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()


def DD(arg): return defaultdict(arg)



def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
  arr = []
  temp = n
  for i in range(2, int(-(-n**0.5//1))+1):
    if temp%i==0:
      cnt=0
      while temp%i==0: 
        cnt+=1 
        temp //= i
      arr.append([i, cnt])
  if temp!=1:
    arr.append([temp, 1])
  if arr==[]:
    arr.append([n, 1])
  return arr


def make_divisors(n):
  divisors = []
  for i in range(1, int(n**0.5)+1):
    if n % i == 0:
      divisors.append(i)
      if i != n // i: 
        divisors.append(n//i)
  return divisors


def make_primes(N):
  max = int(math.sqrt(N))
  seachList = [i for i in range(2,N+1)]
  primeNum = []
  while seachList[0] <= max:
    primeNum.append(seachList[0])
    tmp = seachList[0]
    seachList = [i for i in seachList if i % tmp != 0]
  primeNum.extend(seachList)
  return primeNum


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a


def lcm(a, b):
    return a * b // gcd (a, b)


def count_bit(n):
  count = 0
  while n:
    n &= n -1
    count += 1
  return count


def base_10_to_n(X, n):
  if X//n:
    return base_10_to_n(X//n, n)+[X%n]
  return [X%n]

def base_n_to_10(X, n):
  return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))


def int_log(n, a):
  count = 0
  while n>=a:
    n //= a
    count += 1
  return count




N,H,W = IL()
ans = 0
for _ in range(N):
  a,b = IL()
  if a>=H and b>=W:
    ans += 1
print(ans)

Solution (Python):
N ,H , W = map(int, input().split())
block = [list(map(int,input().split())) for i in range(N)]
cnt = 0
for l in block:
    if (l[0] >= H and l[1] >= W):
        cnt = cnt + 1
print(cnt)

Solution (Python):
n,h,w = list(map(int, input().split())) 
sizeList = [list(map(int, input().split()))  for _ in range(n)]

cnt = 0
for row in sizeList:
    if( row[0] >= h and row[1] >= w):
        cnt += 1
print(cnt)

Solution (Python):
n, h, w = map(int, input().split())
a_b = [ list(map(int, input().split())) for _ in range(n) ]

c = 0
for a, b in a_b:
    if h <= a and w <= b:
        c+=1
print(c)

Solution (Python):
n,h,w=list(map(int,input().split()))
cnt=0
for i in range(n):
  a,b=list(map(int,input().split()))
  if a>=h and b>=w:
    cnt+=1
print(cnt)

Solution (Python):
n, h, w = map(int,input().split())
li = [list(map(int,input().split())) for i in range(n)]
ans = 0

for l in li:
    if l[0] >= h and l[1] >= w:
        ans += 1

print(ans)

Solution (Python):
n,h,w=map(int,input().split())
ans=0
for i in range(n):
    a,b=map(int,input().split())
    if a>=h and b>=w:
        ans+=1
print(ans)

Solution (Python):
def caddi18b_b():
    N, H, W = map(int, input().split())
    P = [tuple(map(int, input().split())) for _ in range(N)]

    ans = 0
    for a, b in P:
        if H <= a and W <= b: ans += 1
    print(ans)

caddi18b_b()

Solution (Python):
N,H,W=map(int,input().split())
ans=0
for i in range(N):
    A,B=map(int,input().split())
    if A>=H and B>=W:
        ans+=1
print(ans)

Solution (Python):
n,h,w=map(int,input().split())
ab = []
for _ in range(n):
  ab.append(input().split())
  ab[-1][0] = int(ab[-1][0])
  ab[-1][1] = int(ab[-1][1])
  if ab[-1][0] < h or ab[-1][1] < w:
    ab.pop()
print(len(ab))

Solution (Python):
n,h,w = map(int,input().split())
count = 0
for i in range(n):
    a,b = map(int,input().split())
    if a >= h and b >= w:
        count+=1
print(count)

Solution (Python):
N,H,W = list(map(int, input().split()))

ans = 0
for i in range(N):
    A,B = list(map(int, input().split()))
    if A >= H and B >= W:
        ans += 1
print(ans)

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline

n,h,w = map(int, input().split())

a = [0]* n
b = [0]* n
for i in range(n):
    a[i], b[i] = map(int, input().split())

ans = 0
for i in range(n):
    if a[i] >= h and b[i] >= w:
        ans+=1

print(ans)

Solution (Python):
n,h,w = map(int,input().split())
abl = [list(map(int,input().split())) for nesya in range(n)]
c = 0
for ab in abl:
  if ab[0] >= h and ab[1] >= w:
    c += 1
print(c)

Solution (Python):
N,H,W=map(int,input().split())
board=0
for i in range(N):
    a,b=map(int,input().split())
    if H<=a and W<=b:
        board+=min(a//H,b//W)
print(board)

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7


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


def main():
    N, H, W = map(int, input().split())
    ans = 0
    for _ in range(N):
        a, b = map(int, input().split())
        if H <= a and W <= b:
            ans += 1

    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
import heapq
from sys import stdin
input = stdin.readline




N,H,W = map(int, input().split())




ab=[]
for i in range(N):
    a,b = map(int, input().split())
    ab.append((a,b))
def main():
    ans = 0 
    for a,b in ab:
        if a>=H and b >=W:
            ans+=1
    print(ans)
    
if __name__ == '__main__':
    main()

Solution (Python):
n, h, w = map(int, input().split())
ans = 0
for i in range(n):
    a, b = map(int, input().split())
    if a >= h and b >= w:
        ans += 1
print(ans)

Solution (Python):
N,H,W=map(int,input().split())
a=[list(map(int,input().split())) for _ in range(N)]
ans=0
for i in range(N):
    if H<=a[i][0] and W<=a[i][1] :
        ans+=1
    else :
        ans+=0
print(ans)

Solution (Python):
N,H,W = map(int,input().split())

count = 0
for i in range(N):
    a,b = map(int,input().split())
    
    if a >= H and b >= W :
        count += 1
print(count)

Solution (Python):
N,H,W=map(int,input().split())
a=[list(map(int,input().split())) for _ in range(N)]
ans=0
for i in range(N):
    if H<=a[i][0] and W<=a[i][1] :
        ans+=1
    else :
        ans+=0
print(ans)

Solution (Python):
from sys import stdin
import math
import re
import queue

input = stdin.readline

MOD = 1000000007
INF = 122337203685477580

def solve():
    N,H,W = map(int, input().split())
    cnt = 0
    for x in range(N):
        h,w = map(int, input().split())
        if(h >= H and w >= W):
            cnt += 1
    print(cnt)

if __name__ == '__main__':
    solve()

Solution (Python):
N, H, W = map(int, input().split())
ans = 0

for i in range(N):
    a, b = map(int, input().split())
    if H <= a and W <= b:
        ans += 1

print(ans)

Solution (Python):
n, h, w = map(int, input().split())
ans = 0
for i in range(n):
    a, b = map(int, input().split())
    if a >= h and b >= w:
        ans += 1
print(ans)

Solution (Python):
N,H,W = list(map(int,input().split()))
ABL = [list(map(int,input().split())) for _ in range(N)]
count = 0
for AB in ABL:
    if AB[0] >= H and AB[1] >= W:
        count += 1
print(count)

Solution (Python):
from sys import stdin
N, H, W = [int(_) for _ in stdin.readline().rstrip().split()]
AB = [list(map(int, stdin.readline().rstrip().split())) for _ in range(N)]
ans = 0
for a, b in AB:
    if H <= a and W <= b:
        ans += 1
print(ans)

Solution (Python):
N, H, W = map(int, input().split())
A = []
B = []
for i in range(N):
    A_, B_ = map(int, input().split())
    A.append(A_)
    B.append(B_)

ans = 0
for i in range(N):
    if A[i] >= H and B[i] >= W:
        ans += 1

print(ans)

Solution (Python):
n,h,w = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(n)]

ans = 0
for a,b in ab:
  if a >= h and b >= w: ans += 1
print(ans)

Solution (Python):
N, H, W = map(int, input().split())
cnt = 0
for _ in range(N):
    a, b = map(int, input().split())
    
    if a>=H and b>=W:
        cnt += 1

print(cnt)

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():
    
    n,h,w=map(int,input().split())
    cnt=0
    A, B = [0] * n, [0] * n
    for i in range(n):
        a,b=map(int,input().split())
        if a>=h and b>=w:
            cnt+=1
    print(cnt)

    
    

    
resolve()

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

def resolve():
    n,h,w=map(int, input().split())
    cnt=0
    for i in range(n):
        a,b=map(int, input().split())
        if a>=h and b>=w:
            cnt+=1
    print(cnt)
resolve()

Solution (Python):
n,h,w = map(int,input().split())
ab_inputs = [list(map(int,input().split())) for i in range(n)]

ans=0
for i in range(n):
    a,b = map(int,ab_inputs[i])
    if a>=h and b>=w:
        ans+=1
print(ans)

Solution (Python):
n,h,w = map(int,input().split())
ans = 0
for i in range(n):
  a,b = map(int,input().split())
  if a >= h and b >= w:
    ans += 1
print(ans)

Solution (Python):
n,h,w=map(int,input().split())
ans = 0
for i in range(n):
    a,b=map(int,input().split())
    if a>=h and b>=w:
        ans+=1
print(ans)

Solution (Python):
N,H,W=map(int,input().split())
ans=0
for _ in range(N):
    A,B=map(int,input().split())
    if H<=A and W<=B: ans+=1
print(ans)

Solution (Python):
n,h,w = map(int,input().split())

c = 0

for i in range(n):
    a,b = map(int,input().split())
    if(h <= a and w <= b):c +=1
print(c)

Solution (Python):

N, H, W = [int(s) for s in input().split()]
R = [[int(s) for s in input().split()] for _ in range(N)]

count = 0

for i in range(N):
    if R[i][0] >= H and R[i][1] >= W:
        count += 1

print(count)

Solution (Python):

n,h,w = map(int,input().split())
ans = 0

for i in range(n):
    a,b = map(int,input().split())
    if a >= h and b >= w:
        ans += 1

print(ans)

Solution (Python):
n, h, w = map(int, input().split())
ab=[map(int,input().split()) for _ in range(n)]
a, b = [list(_) for _ in zip(*ab)]
ans=0
for i in range(n):
    if a[i] >= h and b[i] >= w:
        ans += 1
print(ans)

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    

    n,h,w = map(int, input().split())
    res = 0
    for _ in range(n):
        a,b = map(int, input().split())
        if a>=h and b>=w:
            res += 1
    print(res)

if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin, stdout
import math
import bisect
import queue

N,H,W = map(int,stdin.readline().strip().split())

ans = 0

for i in range(N):
    A, B = map(int, stdin.readline().strip().split())
    ans += min(A // H, B // W)

stdout.writelines(str(ans) + '\n')

Solution (Python):
n, w, h = map(int, input().split())
ans = 0

for _ in range(n):
  wi, hi = map(int, input().split())
  if wi >= w and hi >= h:
    ans += 1
    
print(ans)

Solution (Python):
def i(): return map(int, input().split())
n, h, w = i()
c = 0
for _ in range(n):
  a, b = i()
  c += (a >= h)*(b >= w)
print(c)

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    n,h,w=map(int,input().split())
    ans=0
    for i in range(n):
        a,b=map(int,input().split())
        if a>=h and b>=w:
            ans+=1
    print(ans)

if __name__=='__main__':
    main()

Solution (Python):
import sys
input = sys.stdin.readline

n, h, w = map(int,input().split())
A = [list(map(int,input().split())) for i in range(n)]

ans = 0
for i in range(n):
    if A[i][0] >= h and A[i][1] >= w:
        ans += 1
print(ans)

Solution (Python):
n, h, w = map(int, input().split())
cnt = 0
for i in range(n):
    a, b = map(int, input().split())
    if a >= h and b >= w:
        cnt += 1
print(cnt)

Solution (Python):
n,h,w=map(int, input().split())
c=0
for i in range(n):
  A,B=map(int, input().split())
  if A>=h and B>=w:
    c+=1
print(c)

Solution (Python):
n,h,w = map(int, input().split())
res = 0
for i in range(n):
  a,b = map(int, input().split())
  if a >= h and b >= w:
    res += 1
print(res)

Solution (Python):
N, H, W = map(int,input().split())
ans = 0
for i in range(N):
  A, B = map(int,input().split())
  if A >= H and B >= W: ans += 1
print(ans)

Solution (Python):
n, h , w = map(int, input().split())
ans = 0
for _ in range(n):
    a, b = map(int, input().split())
    if a >= h and b >= w:
        ans += 1
print(ans)

Solution (Python):
N, H, W = map(int, input().split())
ans = 0
for i in range(N):
    a, b = map(int, input().split())
    if a >= H and b >= W:
        ans += 1
print(ans)

Solution (Python):
n, h, w = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(n)]

ans = 0
for i in range(n):
    a = ab[i][0]
    b = ab[i][1]
    if a >= h and b >= w:
        ans += 1
print(ans)

Solution (Python):
n,h,w=map(int,input().split())
ans=0
for a in range(n):
  H,W=map(int,input().split())
  if H>=h and W>=w:ans+=1
print(ans)

Solution (Python):
n,h,w = map(int,input().split())
s = [list(map(int,input().split())) for _ in range(n)]
cnt = 0
for a in s:
    if a[0] >= h and a[1] >= w:
        cnt+=1
print(cnt)

Solution (Python):
n, h, w = map(int, input().split())
a_b = [list(map(int, input().split())) for _ in range(n)]
cnt = 0
for i in range(n):
  if a_b[i][0] >= h and a_b[i][1] >= w:
    cnt += 1
print(cnt)

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = 1e10


def solve():
    n, h, w = LI()
    ab = LIR(n)
    ans = 0
    for a, b in ab:
        if a >= h and b >= w:
            ans += 1
    print(ans)
    return



if __name__ == '__main__':
    solve()

Solution (Python):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))

n,h,w = iim()
ans = 0
for i in range(n):
    a,b = iim()
    if a >= h and b >= w:
        ans += 1
print(ans)

Solution (Python):
n, h, w = map(int, input().split())

t = 0
for i in range(n):
    a, b = map(int, input().split())
    if h <= a and w <= b:
        t += 1
print(t)

Solution (Python):
n,h,w=map(int,input().split())
ans=0
for _ in range(n):
    a,b=map(int,input().split())
    if a>=h and b>=w: ans+=1
print(ans)

Solution (Python):
n, h, w = map(int, input().split())
ab = [list(map(int, input().split())) for i in range(n)]
cnt = 0
for j in ab:
    if j[0] >= h and j[1] >= w:
        cnt += 1
print(cnt)

Solution (Python):
N,H,W = map(int,input().split())
A=[0]*N
B=[0]*N

cnt=0
for i in range(N):
  A[i],B[i]=map(int,input().split())
  if A[i]>=H and B[i]>=W:
    cnt +=1
    
print(cnt)

Solution (Python):
n, h, w = map(int, input().split())
ans = 0
for _ in range(n):
    a, b = map(int, input().split())
    if a >= h and b >= w:
        ans += 1
print(ans)

Solution (Python):
n, h, w = map(int, input().split())
alloy = [list(map(int, input().split())) for _ in range(n)]

res = 0
for i in alloy:
    a, b = i[0], i[1]
    if a >= h and b >= w:
        res += 1

print(res)

Solution (Python):
n,h,w=map(int,input().split())
cnt=0
for i in range(n):
    a,b=map(int,input().split())
    cnt+=min(a//h, b//w)
print(cnt)

Solution (Python):

from sys import setrecursionlimit
setrecursionlimit(10**6)
from collections import Counter
def inputlist(): return [int(j) for j in input().split()]

N,H,W = inputlist()
count = 0
for i in range(N):
    A,B = inputlist()
    if A >= H and B >= W:
        count+=1
print(count)

Solution (Python):
import sys
input = sys.stdin.readline

n, h, w = map(int, input().split())
ab = [list(map(int, input().split())) for i in range(n)]
ans = 0
for i in range(n):
    if ab[i][0] >= h and ab[i][1] >= w:
        ans += 1
print(ans)

Solution (Python):
n, h, w = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(n)]

ans = 0
for a, b in ab:
    if a >= h and b >= w:
        ans += 1

print(ans)

Solution (Python):
n,h,w=map(int,input().split())
ans=0
for i in range(n):
  a,b=map(int,input().split())
  if a>=h and b>=w:
    ans+=1
print(ans)

Solution (Python):
def main():
    plates, height, width = map(int, input().split())
    answer = 0
    for _ in range(plates):
        h, w = map(int, input().split())
        if height <= h and width <= w:
            answer += 1
    print(answer)


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    import sys
    input = sys.stdin.buffer.readline
    N, H, W = (int(i) for i in input().split())
    AB = [[int(i) for i in input().split()] for j in range(N)]
    ans = 0
    for a, b in AB:
        ans += min(a//H, b//W)
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
N,H,W = map(int, input().split())
count = 0
for i in range(N):
  A,B = map(int,input().split())
  if A >= H and B >= W:
    count = count + 1
print(count)

Solution (Python):
n,h,w = map(int,input().split())
ans = 0

for i in range(n):
    a,b = map(int,input().split())
    if h <= a and w <= b:
        ans += 1


print(ans)

Solution (Python):
N, H, W = map(int, input().split())
ans = 0
for i in range(N):
    A, B = map(int, input().split())
    ans += (A >= H and B >= W)
print(ans)

Solution (Python):
N, H, W = map(int, input().split())
ans = 0
for _ in range(N):
  A, B = map(int, input().split())
  if A >= H and B >= W:
    ans += 1
print(ans)

Solution (Python):
N,H,W = map(int,input().split())
ans = 0
for i in range(N):
    h,w = map(int,input().split())
    if (h >= H)and(w >= W):
        ans += 1

print(ans)

Solution (Python):
n, h, w = map(int, input().split())
ls = [list(map(int, input().split())) for _ in range(n)]

ans = 0

for ab in ls:
	if ab[0] >= h and ab[1] >= w:
		ans += 1

print(ans)

Solution (Python):
def main():
    n, h, w = map(int, input().split())
    ans = 0
    for _ in range(n):
        a, b = map(int, input().split())
        if a >= h and b >= w:
            ans += 1
    print(ans)

if __name__ == "__main__":
    main()

Solution (Python):
N, H, W = map(int, input().split())
P = [tuple(map(int, input().split())) for i in range(N)]

print(len(list(filter(lambda p: p[0] >= H and p[1] >= W, P))))

Solution (Python):
N, H, W = map(int, input().split())
count = 0
for n in range(N):
    A, B = map(int, input().split())
    if A >= H and B >= W:
        count += 1
print(count)

Solution (Python):
n,h,w = map(int,input().split())
res = 0
for i in range(n):
    a,b = map(int,input().split())
    if a >= h and b >= w:
        res+=1
print(res)

Solution (Python):
N,H,W=map(int,input().split())
mat=[list(map(int,input().split())) for _ in range(N)]
c=0
for i in range(N):
    if (mat[i][0]>=H)and(mat[i][1]>=W):
        c=c+1
print(c)

Solution (Python):
n,h,w=map(int,input().split())
c=0
for i in range(n):
  a,b=map(int,input().split())
  if a>=h and b>=w:
    c+=1
print(c)

Solution (Python):
n, h, w = map(int, input().split())
al, bl = [], []
for _ in range(n):
    a, b = map(int, input().split())
    al.append(a)
    bl.append(b)

ans = 0
for a, b in zip(al, bl):
    if a >= h and b >= w:
        ans += 1
print(ans)

Solution (Python):
N,H,W=map(int,input().split())
ret = 0
for i in range(N):
  a,b=map(int,input().split())
  if a>=H and b>=W:
    ret += 1
print(ret)

Solution (Python):
N, H, W = map(int, input().split())
ans = 0
for _ in range(N):
    A, B = map(int, input().split())
    if A>=H and B>=W:
        ans += 1

print(ans)

Solution (Python):
n,h,w=map(int,input().split())
ans=0
for i in range(n):
    a,b=map(int,input().split())
    if a>=h and b>=w:
        ans+=1
print(ans)

Solution (Python):
import sys

read = sys.stdin.read

N, H, W, *AB = map(int, read().split())
answer = 0
for a, b in zip(*[iter(AB)] * 2):
    if H <= a and W <= b:
        answer += 1

print(answer)

Solution (Python):
n, h, w = map(int, input().split())

ans = 0
for _ in range(n):
    a, b = map(int, input().split())
    if a >= h and b >= w:
        ans += 1
print(ans)

Solution (Python):
N, H, W = map(int, input().split())
ok = lambda ab: ab[0]>=H and ab[1]>=W
print(sum(ok(tuple(map(int, input().split()))) for _ in range(N)))

Solution (Python):
N,H,W=map(int,input().split())
AB=[list(map(int,input().split())) for i in range(N)]
ans=0
for i in range(N):
  if AB[i][0]>=H and AB[i][1]>=W:
    ans+=1
print(ans)

Solution (Python):
n, h, w = map(int, input().split())
res = 0
for _ in range(n):
    hh,ww = map(int, input().split())
    if hh >= h and ww >= w:
        res += 1
print(res)

Solution (Python):


n, h, w = [int(x) for x in input().split()]
c = 0
for _ in range(n):
    a, b = [int(x) for x in input().split()]
    if a >= h and b >= w:
        c += 1
print(c)

Solution (Python):

import sys


def solve(N: int, H: int, W: int, A: "List[int]", B: "List[int]"):
    answer = 0
    for i in range(N):
        if H <= A[i] and W <= B[i]:
            answer += 1
    print(answer)
    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))  
    H = int(next(tokens))  
    W = int(next(tokens))  
    A = [int()] * (N)  
    B = [int()] * (N)  
    for i in range(N):
        A[i] = int(next(tokens))
        B[i] = int(next(tokens))
    solve(N, H, W, A, B)

if __name__ == '__main__':
    main()

Solution (Python):
N, H, W = map(int, input().split())
cnt = 0
for i in range(N):
    A, B = map(int, input().split())
    if(A >= H and B >= W):
        cnt += 1
print(cnt)

Solution (Python):


n,h,w = map(int,input().split())
cnt = 0
for i in range(n):
    a,b = map(int,input().split())
    if a >= h and b >= w:  cnt += 1
print(cnt)

Solution (Python):
N, H, W = map(int, input().split())

ans = 0
for _ in range(N):
  a, b = map(int, input().split())
  if a >= H and b >= W:
    ans += 1
    
print(ans)

Solution (Python):
N,H,W = map(int,input().split())
A = []
B = []
for i in range(N):
	a,b = map(int,input().split())
	A.append(a)
	B.append(b)
cnt = 0
for i in range(N):
	if A[i] >= H and B[i] >= W:
		cnt+=1
print(cnt)

Solution (Python):
n,h,w=map(int,input().split())
c=0
for _ in range(n):
  a,b=map(int,input().split())
  if a>=h and b>=w:
    c+=1
print(c)

Solution (Python):
n, h, w = map(int, input().split())
ab = [input().split() for _ in range(n)]
c = 0

for i in range(n):
	if int(ab[i][0]) >= h and int(ab[i][1]) >= w:
		c += 1

print(c)

Solution (Python):
N, H, W = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(N)]
ans = 0
for i in range(N):
    if (AB[i][0] >= H) and (AB[i][1] >= W):
        ans += 1
print(ans)

Solution (Python):
n,h,w=map(int,input().split())
c=0
for i in range(n):
  a,b=map(int,input().split())
  if a>=h and b>=w:
    c+=1
print(c)

Solution (Python):
A,B,C =  map(int,input().split())
count = 0
for _ in range(A):
  D,E = map(int,input().split())
  if B <= D  and C <=  E:
    count += 1
print(count)

Solution (Python):
from sys import stdin

n,h,w = [int(x) for x in stdin.readline().rstrip().split()]
li = [list(map(int,stdin.readline().rstrip().split())) for _ in range(n)]
point = 0
for i in li:
    if i[0] >= h and i[1] >= w:
        point += 1
print(point)

Solution (Python):
def main():
    N,H,W = map(int,input().split())
    A,B = [],[]
    for _ in range(N):
        a,b = map(int,input().split())
        A.append(a)
        B.append(b)
    ans = 0
    for i in range(N):
        if H<=A[i] and W<=B[i]:
            ans += 1
    print(ans)
if __name__ == '__main__':
    main()

Solution (Python):
n, h, w = map(int, input().split())
a,b = [],[]
for _ in range(n):
	ta, tb = map(int, input().split())
	a.append(ta)
	b.append(tb)
cnt = 0
for i in range(n):
	if a[i] >= h and b[i] >= w:
		cnt += 1

print(cnt)

Solution (Python):
inputs=lambda:map(int,input().split())
cnt=0
n,h,w=inputs()
for i in range(n):
  a,b=inputs()
  if a>=h and b>=w:
    cnt+=1
    
print(cnt)

Solution (Python):
N,H,W = map(int, input().split())
R = 0
for x in range(N):
  h,w = map(int, input().split())
  if h >= H and w >= W:
    R += 1
print(R)

Solution (Python):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

n,h,w = map(int,input().split())
for i in range(n):
    a,b=map(int,input().split())
    if (a>=h) and (b>=w):
        count+=1
print(count)

Solution (Python):
N,H,W = map(int,input().split())
result = 0
for i in range(N):
  A,B = map(int,input().split())
  if A >= H and B >= W:
    result += 1
print(result)

Solution (Python):
n,h,w = map(int,input().split())

ans = 0

for i in range(n):
	a,b=map(int,input().split())
	if a>=h and b>=w:
		ans = ans + 1

print(ans)

Solution (Python):
n,h,w=map(int,input().split())
cnt=0
for i in range(n):
  a,b=map(int,input().split())
  if a>=h and b>=w:
    cnt+=1
print(cnt)

Solution (Python):
N, H, W = map(int,input().split())
ans = 0
for _ in range(N):
  a,b = map(int,input().split())
  if a>=H and b>=W:ans += 1
print(ans)

Solution (Python):
N,H,W=map(int,input().split())
A = []
B = []
for i in range(N):
    x1,y1=[int(i) for i in input().split()]
    A.append(x1)
    B.append(y1)

cnt=0

for i in range(N):
    if A[i]>=H and B[i]>=W:
        cnt+=1

print(cnt)

Solution (Python):
N, H, W = map(int, input().split())

cnt = 0

for i in range(0, N):
	a, b = map(int, input().split())
	if a >= H and b >= W:
		cnt += 1

print(cnt)

Solution (Python):
li = list(map(int,input().split()))
ans=0
for i in range(li[0]):
    x,y = map(int,input().split())
    if x>=li[1] and y>=li[2]:
        ans+=1
print(ans)

Solution (Python):
N, H, W = map(int, input().split())
ans = 0
for _ in range(N):
    a, b = map(int, input().split())
    if a>=H and b>= W: ans += 1
print(ans)

Solution (Python):
n,h,w = map(int,input().split())
ans = 0
for _ in range(n):
    a,b = map(int,input().split())
    if a >= h and b >= w:
        ans += 1
print(ans)

Solution (Python):
n,h,w = map(int,input().split())
ans=0

for i in range(n):
    a,b = map(int,input().split())
    if a>=h and b>=w:
        ans+=1
print(ans)

Solution (Python):
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    n, h, w = list(map(int, readline().split()))
    cnt = 0
    for i in range(n):
        a, b = list(map(int, readline().split()))
        if a >= h and b >= w:
            cnt += 1
    print(cnt)


if __name__ == '__main__':
    solve()

Solution (Python):
n,h,w=map(int,input().split())
ans=0
for _ in range(n):
  a,b=map(int,input().split())
  if a>=h and b>=w:
    ans+=1

print(ans)

Solution (Python):
n,h,w,*L=map(int,open(0).read().split());print(sum(h-x<=0<=y-w for x,y in zip(*[iter(L)]*2)))

Solution (Python):
n, h, w = map(int, input().split())
ab = []
for i in range(n):
    ab.append(list(map(int, input().split())))
cnt = 0
for j in ab:
    if j[0] >= h and j[1] >= w:
        cnt += 1
print(cnt)

Solution (Python):
N, H, W = map(int,input().split())
AB = [list(map(int,input().split())) for _ in range(N)]

ans = 0

for A, B in AB:
    ans += A >= H and B >= W

print(ans)

Solution (Python):
N, H, W = map(int,input().split())
AB = [list(map(int,input().split())) for _ in range(N)]

ans = 0

for A, B in AB:
    ans += A >= H and B >= W

print(ans)

Solution (Python):
N, H, W = map(int,input().split())
AB = [list(map(int,input().split())) for _ in range(N)]
cnt = 0
for i in range(N):
  if AB[i][0] >= H and AB[i][1] >= W:
    cnt += 1
print(cnt)

Solution (Python):
N,H,W = map(int,input().split())
cnt = 0
for _ in range(N):
    a,b = map(int,input().split())
    if a>=H and b>=W:
        cnt += 1
print(cnt)

Solution (Python):

n, h, w = map(int, input().split())
ans = 0

for i in range(0, n):
    a, b = map(int, input().split())
    if h <= a and w <= b:
        ans += 1

print(ans)