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
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())
cnt=0
for i in range(n):
  hh,ww=map(int,input().split())
  if hh>=h and ww>=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 H <= A and W <= B:
    ans += 1
print(ans)

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

cnt=0
for a,b in l:
    cnt+=min(a//h,b//w)
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:
    if a >= H and b >= W:
        ans += 1
print(ans)

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

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

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

Solution (Python):
from sys import stdin
rs = lambda : stdin.readline().strip()
ri = lambda : int(rs())
ril = lambda : list(map(int, rs().split()))

def main():
    N, H, W = ril()
    ans = 0
    for i in range(N):
        a, b = ril()
        if H <= a and W <= b:
            ans += 1
    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
n, h, w = M()
ans = 0
for _ in range(n):
    a, b = M()
    if a >= h and b >= 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 collections import defaultdict
    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,pi,factorial
    from operator import itemgetter
    def I(): return int(input())
    def MI(): return map(int, input().split())
    def LI(): return list(map(int, input().split()))
    def LI2(): return [int(input()) for i in range(n)]
    def MXI(): return [[LI()]for i in range(n)]
    def SI(): return input().rstrip()
    def printns(x): print('\n'.join(x))
    def printni(x): print('\n'.join(list(map(str,x))))
    inf = 10**17
    mod = 10**9 + 7

    n,h,w=MI()
    count=0
    for i in range(n):
        x,y=MI()
        if h<=x and w<=y:
            count+=1
    print(count)
        
        
        
        
    
if __name__=="__main__":
    main()

Solution (Python):

num,h_target,m_target = map(int,input().split())


h_list,m_list = [],[]
for i in range(0,num):
    h,m = map(int,input().split())
    h_list.append(h)
    m_list.append(m)

cnt = 0
for i in range(0,num):
    if h_list[i] >= h_target and m_list[i] >= m_target:
        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):
mod = 1000000007
eps = 10**-9


def main():
    import sys
    input = sys.stdin.readline

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

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 = [0] * n
b = [0] * n
for i in range(n):
    a[i], b[i] = map(int, input().split())

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

print(count)

Solution (Python):
n, h, w = map(int, input().split())
cnt = 0
for _ in range(n):
    a, b = map(int, input().split())
    if h <= a and w <= b:
        cnt += 1
    else:
        continue
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())
count=0
for i in range(n):
    a,b=list(map(int,input().split()))
    if a>=h and b>=w:
        count += 1
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):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    N, H, W = map(int, readline().split())

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

    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    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)


if __name__ == "__main__":
    main()

Solution (Python):
import sys, math
from functools import lru_cache
import numpy as np
import heapq
from collections import defaultdict
sys.setrecursionlimit(10**9)
MOD = 10**9+7

def input():
    return sys.stdin.readline()[:-1]

def mi():
    return map(int, input().split())

def ii():
    return int(input())

def i2(n):
    tmp = [list(mi()) for i in range(n)]
    return [list(i) for i in zip(*tmp)]


def main():
    N, H, W = mi()
    A, B = i2(N)
    
    cnt = 0
    for a, b in zip(A, B):
        if a >= H and b >= W:
            cnt += 1
    print(cnt)

if __name__ == '__main__':
    main()

Solution (Python):
N, H, W = map(int, input().split())
ans = 0
for _ in range(N):
    A, B = map(int, input().split())
    if A<H or B<W:
        continue
    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())
ab = [list(map(int, input().split())) for i 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, x, y = map(int, input().split())
l = [list(map(int, input().split())) for i in range(n)]
ans = 0
for i in range(n):
    if l[i][0] >= x and l[i][1] >= y:
        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):
    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())
print(n-sum(a<h or b<w for a,b in [list(map(int,input().split())) for i in range(n)]))

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
import itertools
import collections
import heapq
import re
import numpy as np
from functools import reduce

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

n, h, w = rm()
cnt = 0
for _ in range(n):
    a, b = rm()
    if a >= h and b >= w:
        cnt += 1
print(cnt)

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

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):
    tate,yoko=map(int,input().split())
    if tate>=h and yoko>=w:
        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):
ans=0
N,A,B=map(int,input().split())
for i in range(N):
  A1,B2=map(int,input().split())
  if A<=A1 and B<=B2:
    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(' '))
    while (0 <= a - h and 0 <= b - w):
        a -= h
        b -= w
        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())
g = []
for i in range(n):
    a, b = map(int, input().split())
    g.append([a, b])
ans = 0
for ai, bi in g:
    if ai >= h and bi >= w:
        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())

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


def main():
    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)


if __name__ == '__main__':
    main()

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

Solution (Python):

import sys
from time import time, sleep
from random import random
from bisect import bisect, bisect_left
def inpl(): return list(map(int, input().split()))
N, H, W = inpl()
cnt = 0
for _ in range(N):
    a, b = inpl()
    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):
import sys

def solve():
    input = sys.stdin.readline
    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)
    return 0

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 H<=A and W<=B:
    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):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    N, H, W = LI()
    AB = [LI() for _ in range(N)]

    ans = len([(A, B) for A, B in AB if A >= H and B >= W])
    print(ans)

if __name__ == '__main__':
    resolve()

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


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

if __name__ == '__main__':
    main()

Solution (Python):
import sys
INF = 1 << 60
MOD = 10**9 + 7 
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
    n, h, w = map(int, input().split())
    ans = 0
    for _ in range(n):
        a, b = map(int, input().split())
        ans += a >= h and b >= w
    print(ans)
resolve()

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

ans = 0
for size in sizes:
    if size[0] >= h and size[1] >= w:
        ans += 1
print(ans)

Solution (Python):
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)

Solution (Python):
from operator import itemgetter
from itertools import *
from bisect import *
from collections import *
from heapq import *
from fractions import Fraction
import sys

sys.setrecursionlimit(10 ** 6)

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 SI(): return sys.stdin.readline()[:-1]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
int1 = lambda x: int(x) - 1
def MI1(): return map(int1, sys.stdin.readline().split())
def LI1(): return list(map(int1, sys.stdin.readline().split()))
p2D = lambda x: print(*x, sep="\n")
dij = [(1, 0), (0, 1), (-1, 0), (0, -1)]

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

Solution (Python):
N, H, W = map(int, input().split())
ans = 0
for _ in range(N):
    A, B = map(int, input().split())
    if A >= H:
        if 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())
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):
import sys

input = sys.stdin.readline


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 _ 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())
ab=[list(map(int,input().split()))for _ in range(N)]
print(sum((a>=H)*(b>=W)for a,b in ab))

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, 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

N, H, W = MAP()
AB = [LIST() for _ in range(N)]

print(sum(y>=H and x>=W for y, x in AB))

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

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    mod=10**9+7
    N,H,W=MI()
    ans=0
    for i in range(N):
        a,b=MI()
        if a>=H and b>=W:
            ans+=1
            
    print(ans)

main()

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
def gcd(*numbers): reduce(math.gcd, numbers)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
count = 0
ans = 0

N, H, W =I()
board = []
for i in range(N):
    a = l()
    board.append(a)

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

for num in range(n):
    cut=int(a[num][0]/h)
    cutw=int(a[num][1]/w)
    if cut==0 or cutw==0:
        cut=0
        cutw=0
    if cutw<cut:
        cut=cutw
    ans+=cut
    
print(ans)

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


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

Solution (Python):
from sys import stdin, setrecursionlimit


def main():
    input = stdin.buffer.readline
    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__":
    setrecursionlimit(10000)
    main()

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 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())
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 sys
from typing import Any, Callable, Deque, Dict, List, Mapping, Optional, Sequence, Set, Tuple, TypeVar, Union






























def main():
    mod = 1000000007                
    inf = float('inf')              
    
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def isp():   return input().split()
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    n, h, w = mi()
    cnt = 0
    for _ in range(n):
        a, b = mi()
        if a >= h and b >= w:
            cnt += 1
    print(cnt)


if __name__ == "__main__":
    main()

Solution (Python):
def main():
    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)

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 += 1
print(count)

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

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

print(p)

Solution (Python):
def resolve():
    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 A[i] >= H and B[i] >= W:
            ans += 1
    print(ans)
resolve()

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

count = 0
for ab in AB:
    a = ab[0]
    b = ab[1]
    if a >= H and b >= W:
        count += 1
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):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

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

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

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

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

cnt = 0
for v in lst:
    if v[0] >= H and v[1] >= W:
        cnt += 1
print(cnt)

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

cnt = 0
for v in lst:
    if v[0] >= H and v[1] >= W:
        cnt += 1
print(cnt)

Solution (Python):
n,h,w=map(int,input().split())
a,b=[list(map(int,input().split())) for i in range(n)],0
for i in a:
    b+=(i[0]>=h and i[1]>=w)
print(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):
import sys
readline = sys.stdin.readline

N,H,W = map(int,readline().split())
ans = 0
for i in range(N):
  a,b = map(int,readline().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):
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
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, insort, insort_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


N, H, W = MAP()

ans = 0
for _ in range(N):
	A, B = MAP()
	if H <= A and W <= B:
		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 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):
  s,t=map(int,input().split())
  ans+=(s>=h and t>=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):
    a,b=map(int,input().split())
    if a>=h and b>=w:
        ans+=1
print(ans)