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):
N,H,W = map(int,input().split())
ans = 0
k = []
for i in range(N):
  k.append(list(map(int,input().split())))
for i in range(N):
  if k[i][0]>=H and k[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 ab in AB:
    if ab[0] >= H and ab[1] >= 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):
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 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 H <= a and W <= b:
    ans += 1

print(ans)

Solution (Python):

import sys
sys.setrecursionlimit(10000000)
INF = 1<<32


def solve(N: int, H: int, W: int, A: "List[int]", B: "List[int]"):
    print([A[i] >= H and B[i] >= W for i in range(N)].count(True))
    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())
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 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):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
 



 




 


 





 


 
def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
 
def main():
    N,H,W = inputMap()
    AB = []
    for i in range(N):
        a,b = inputMap()
        AB.append((a,b))
        
    ans = 0
    for i,val in enumerate(AB):
        a,b = val
        if a >= H and b >= W:
            ans += 1
    
    print(ans)
    
if __name__ == "__main__":
	main()

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

print(counter)

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) & (b >= w):
        ans += 1
print(ans)

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())
li = [list(map(int,input().split())) for _ in range(n)]

cnt = 0
for x,y in li:
    if x >= h and y >= w:
        cnt += 1
        
print(cnt)

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

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

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

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())
A,B=[0]*N,[0]*N
ans=0
for i in range(N):
  A[i],B[i]=map(int,input().split())
  if(A[i]>=H and B[i]>=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 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())
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())
cnt=0
for i in range(n):
  a,b=map(int,input().split())
  cnt+=1 if a>=h and b>=w else 0
print(cnt)

Solution (Python):
n, h, w, *a = list(map(int, open(0).read().split()))

ans = 0
for a, b in zip(*[iter(a)]*2):
    ans += not(a < h or b < w)
print(ans)

Solution (Python):
N, H, W = map(int, input().split())
ret = 0
for _ 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())
cnt=0
for _ in range(n):
    a,b = map(int,input().split())
    if a>=h and b>=w:
        cnt+=1
print(cnt)

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    n, h, w = list(map(int, input().rstrip('\n').split()))
    cnt = 0
    for i in range(n):
        a, b = list(map(int, input().rstrip('\n').split()))
        cnt += min(a // h, b // w)
    print(cnt)


if __name__ == '__main__':
    slove()

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

Solution (Python):


n, h, w = map(int, input().split())
a = [0] * n
b = [0] * n
ans = 0

for i in range(n):
    a[i], b[i] = map(int, input().split())
    if a[i] >= h and b[i] >= 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 = tuple(map(int, input().split()))
ans = 0
for i in range(N):
    a, b = tuple(map(int, input().split()))
    if H <= a and W <= b:
        ans += 1
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())
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):
    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())

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 solve():
  n,h,w = (int(i) for i in input().split())
  ct = 0
  for i in range(n):
    a,b = (int(i) for i in input().split())
    if a>=h and b >= w:
      ct += 1
  print(ct)
solve()

Solution (Python):

def main():
    N, H, W, *AB = map(int, open(0).read().split())
    ans = sum(a >= H and b >= W for a, b in zip(*[iter(AB)] * 2))
    print(ans)


if __name__ == "__main__":
    main()

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

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
    return ans

if __name__ == '__main__':
    print(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())
AB = [list(map(int,input().split())) for _ in [0]*N]
print(sum(a>=H and b>=W for a,b in AB))

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

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

Solution (Python):
n,h,w,*t=map(int,open(0).read().split());print(sum(a>=h and b>=w for a,b in zip(t[::2],t[1::2])))

Solution (Python):
n,h,w = map(int, input().split())
count = 0
for _ 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())
c = 0
for i in range(N):
  H_, W_ = map(int, input().split())
  if H_ >= H and W_ >= W:
    c += 1
print(c)

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())
a=[0]*n
b=[0]*n
ans=0
for i in range(n):
    a[i],b[i]=map(int,input().split())
    if a[i]>=h and b[i]>=w:
        ans+=1
print(ans)

Solution (Python):
n, h, w = [ int(v) for v in input().split() ]
ans = 0
for i in range(n):
  a, b = [ int(v) for v in 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)]
print(len(list(filter(lambda x: x[0] >= h and x[1] >= w, AB))))

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())
ans=0
for i in range(n):
	x,y=map(int,input().split())
	if x>=h and y>=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 h<=a and w<=b:
    cnt+=1
print(cnt)

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

Solution (Python):
N,H,W=map(int,input().split())
li=[map(int,input().split()) for _ in range(N)]
ans=0
for h,w in li:
  if h>=H and w>=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):
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 H <= A[i] and W <= B[i]:
        ans += 1
print(ans)

Solution (Python):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 998244353
eps = 10**-7
def inp(): return int(input())
def inpl(): return list(map(int, input().split()))
def inpl_str(): return list(input().split())

N,H,W = inpl()
ans = 0
for _ in range(N):
    A,B = inpl()
    if H <= A and W <= B:
        ans += 1

print(ans)

Solution (Python):
n, h, w = map(int, input().split())
a = [0] * n
b = [0] * n
ans = 0
for i in range(n):
    a[i], b[i] = map(int, input().split())
    if a[i] >= h and b[i] >= 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())
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())
AB = [list(map(int, input().split())) for _ in range(N)]

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

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
input = sys.stdin.readline

def main():
    n, h, w = list(map(int, input().rstrip().split()))
    R = [list(map(int, input().rstrip().split())) for _ in range(n)]
    ans = sum(1 for a, b in R if a >= h and b >= w)
    print(ans)


if __name__ == "__main__":
    main()

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

for i in range(n):
    hight = ab[i][0] // h
    width = ab[i][1] // w
    if hight >= 1 and width >= 1:
        count += min(hight, width)

print(count)

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 h<=a and w<=b:
        cnt+=1
print(cnt)

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

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 solve(n, h, w, a, b):
    ans = 0
    for i in range(n):
        if (a[i] >= h) and (b[i] >= w):
            ans += 1
    return ans

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())
print(solve(n, h, w, a, b))

Solution (Python):
N, H, W = map(int, input().split())
materials = [tuple(map(int, input().split())) for _ in range(N)]
ans = 0
for h, w in materials:
    if h >= H and w >= 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())
a = []
b = []
for i in range(n):
    tmp1,tmp2 = map(int,input().split())
    a.append(tmp1)
    b.append(tmp2)
counter = 0
for i in range(n):
    if a[i] >= h and b[i] >= w:
        counter +=1
print(counter)

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 = map(int, input().split())

li_ita = list()

for _ in range(n):
    li_ita.append(tuple(map(int, input().split())))

print(len(list(filter(lambda x: x[0] >= h and x[1] >= w, li_ita))))

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

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

answer = 0
for _ in range(N):
  a,b = map(int,input().split())
  if a >= H and b >= W:
    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):
import bisect
import os
from collections import Counter, deque
from fractions import gcd
from functools import lru_cache
from functools import reduce
import functools
import heapq
import itertools
import math
import numpy as np
import re
import sys

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")

N, H, W = list(map(int, sys.stdin.readline().split()))
A, B = list(zip(*[map(int, sys.stdin.readline().split()) for _ in range(N)]))

A = np.array(A)
B = np.array(B)

print(((A >= H) & (B >= W)).sum())

Solution (Python):
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b



def sum_of_arithmetic_progression(s, d, n):
    return n * (2 * s + (n - 1) * d) // 2



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



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


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):
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=[]
b=[]
for _ in range(n):
    aa,bb = map(int,input().split())
    a.append(aa)
    b.append(bb)
ans = 0
for i in range(n):
    ans += min(a[i]//h,b[i]//w)**2
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 input(): return sys.stdin.readline().rstrip()
def mi(): return map(int, input().split())


N, H, W = mi()

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

print(cnt)

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

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):
ans = 0
n, h, w = map(int, input().split())
for i in range(n) :
  a, b = map(int, input().split())
  if h <= a and w <= b : ans = ans + 1
print(ans)

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

Solution (Python):
n, h, w = [int(item) for item in input().split()]
ans = 0
for i in range(n):
  x, y = [int(item) for item in input().split()]
  if x >= h and y >= 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):
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())
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 = [int(c) for c in input().split()]

count = 0

for _ in range(n):
    a, b = [int(c) for c in input().split()]
    if a >= h and b >= 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 = [int(x) for x in input().split()]
ABs = [[int(x) for x in input().split()] for _ in range(N)]

ans = 0
for A, B in ABs:
    if H <= A and W <= B:
        ans += 1

print(ans)

Solution (Python):
nhw = input().split()
n = int(nhw[0])
h = int(nhw[1])
w = int(nhw[2])

ablist = []
for i in range(n):
    ab = input().split()
    a = int(ab[0])
    b = int(ab[1])
    ablist.append((a, b))


count = 0
for a, b in ablist:
    if a >= h and b >= w:
        count += 1

print(count)

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())
cnt=0
for i in range(n):
  a,b=map(int,input().split())
  if h<=a and w<=b:
    cnt+=1
print(cnt)

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

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 h<=a and w<=b:ans+=1
print(ans)

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

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

for i in AB:
    if i[0] >= H and i[1] >= 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(' '))
boards=[list(map(int,input().split(' '))) for i in range(N)]
print(len([1 for board in boards if board[0]>=H and board[1]>=W]))

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
stdin = sys.stdin
 
sys.setrecursionlimit(10**6) 
 
def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x)-1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

n,h,w = li()
ans = 0
for _ in range(n):
    a,b = li()
    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):
N,H,W = map(int,input().split())
AB = [list(map(int,input().split())) for i in range(N)]
count = 0
for i in range(N):
    if AB[i][0] >= H and AB[i][1] >= W:
        count += 1

print(count)

Solution (Python):
a,b,c=map(int,input().split())
ans=0
for s in range(a):
    d,e=map(int,input().split())
    if b<=d and c<=e:
        ans+=1
print(ans)

Solution (Python):
a,b,c=map(int,input().split())
ans=0
for s in range(a):
    d,e=map(int,input().split())
    if b<=d and c<=e:
        ans+=1
print(ans)

Solution (Python):
N,H,W = map(int,input().split())
L = []
for i in range(N):
  L.append(list(map(int,input().split())))
cnt = 0
for i in range(N):
  if L[i][0] >= H and L[i][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)]
z=0
for t in ab:
    if t[0]>=h and t[1]>=w:
        z+=1
print(z)

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

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

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

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

count = 0
for i in range(n):
    if li[i][0] >= h and li[i][1] >= w:
        count += 1

print(count)

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

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

Solution (Python):
a,b,c = map(int,input().split(" "))
count = 0
for i in range(a):
  d,e = map(int,input().split(" "))
  if d >= b and e >= c:
    count += 1
print(count)

Solution (Python):
import re
A = list()
B = list()
stack = 0
N,H,W = map(int,input().split())

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

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

print(stack)

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):
from math import floor
N, H, W = map(int, input().split())
ans = 0
 
for i in range(N):
  A, B = map(int, input().split())
  if (A//H) * (B//W) > 0:
    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=[tuple(map(int, input().split())) for i in range(n)]
c=0
for i in ab:
  if i[0] >= h and i[1] >= w:
    c+=1
    
print(c)

Solution (Python):
n,h,w =list(map(int,input().split()))
ans=0
for _ in range(n):
    a1,b1=list(map(int,input().split()))
    if a1>=h and b1>=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 = [int(i) for i in input().split()]
_ = 0
for i in range(n):
    __ = [int(j) for j in input().split()]
    if __[0]>=h and __[1]>=w:
        _+=1
print(_)

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

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

Solution (Python):
n,h,w,*c=map(int,open(0).read().split());print(sum((a>=h)&(b>=w)for a,b in zip(c[::2],c[1::2])))

Solution (Python):
n,h,w,*c=map(int,open(0).read().split());print(sum((a>=h)&(b>=w)for a,b in zip(c[::2],c[1::2])))

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 w<=b:
        ans+=1
print(ans)

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


if __name__ == '__main__':
    main()

Solution (Python):
N, H, W = map(int, input().split())
cnt = 0
l=[]

while cnt <= N-1:
  _ = [i for i in map(int, input().split())]
  if H <= _[0] and W <= _[1]:
  	l.append(_)
  cnt += 1
  
print(len(l))

Solution (Python):
n, h, w = [int(i) for i in input().split(" ")]
n_boards = 0
for k in range(n):
    hi, wi = [int(i) for i in input().split(" ")]
    if hi >= h and wi >= w:
        n_boards += 1
print(n_boards)

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 numpy as np

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

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

print(count)

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

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

Solution (Python):
i, w, h =  map(int, raw_input().split())

total = 0 

for _ in range(i):
	x,y =  map(int, raw_input().split())
	if w<=x and h<=y:
		total +=1

print total

Solution (Python):
N, H, W =(int(i) for i in input().split())
A = [[int(i) for i in input().split()]for i in range(N)]
a = 0

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

print(a)