# Original solution
import os
import sys
from collections import deque

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

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

N = int(sys.stdin.readline())
AB = [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
CD = [list(map(int, sys.stdin.readline().split())) for _ in range(N)]

S = N * 2
T = N * 2 + 1

graph = [[] for _ in range(N * 2 + 2)]
for i, (a, b) in enumerate(AB):
    for j, (c, d) in enumerate(CD):
        if a < c and b < d:
            rev = [i, 0]
            edge = [j + N, 1, rev]
            rev.append(edge)
            graph[i].append(edge)
            graph[j + N].append(rev)
for i in range(N):
    rev = [S, 0]
    edge = [i, 1, rev]
    rev.append(edge)
    graph[S].append(edge)
    graph[i].append(rev)
for i in range(N):
    rev = [i + N, 0]
    edge = [T, 1, rev]
    rev.append(edge)
    graph[i + N].append(edge)
    graph[T].append(rev)


def bfs(s):
    # s からの距離
    ret = [-1] * len(graph)
    ret[s] = 0
    que = deque([(s, 0)])
    while que:
        v, d = que.popleft()
        for u, cap, _ in graph[v]:
            if ret[u] < 0 and cap > 0:
                ret[u] = d + 1
                que.append((u, d + 1))
    return ret


def dinic(v, t, f, dist, iter):
    if v == t:
        return f
    while iter[v] < len(graph[v]):
        edge = graph[v][iter[v]]
        to, cap, rev = edge
        if dist[v] < dist[to] and cap > 0:
            d = dinic(to, t, min(f, cap), dist, iter)
            if d > 0:
                edge[1] -= d
                rev[1] += d
                return d
        iter[v] += 1
    return 0


flow = 0
while True:
    dist = bfs(S)
    if dist[T] < 0:
        break
    while True:
        f = dinic(S, T, INF, dist, [0] * len(graph))
        if f == 0:
            break
        flow += f
print(flow)


# Optimized solution
import os
import sys

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

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


class Dinic:
    def __init__(self, graph=None, residual=None):
        """
        :param list of (list of (int, int)) graph: (to, cap) の隣接リスト
        :param list of (list of (list of (int|list))) residual: (to, cap, rev) の残余グラフ
        """
        assert (graph and not residual) or (not graph and residual)
        if graph:
            self.graph = self.residual_graph(graph)
        else:
            self.graph = residual

    @staticmethod
    def residual_graph(graph):
        """
        残余グラフ構築
        :param list of (list of (int, int)) graph: (to, cap) の隣接リスト
        :rtype: list of (list of (list of (int|list)))
        :return: (to, cap, rev) の残余グラフ
        """
        ret = [[] for _ in range(len(graph))]
        for v in range(len(graph)):
            for u, cap in graph[v]:
                rev = [v, 0]
                edge = [u, cap, rev]
                rev.append(edge)
                ret[v].append(edge)
                ret[u].append(rev)
        return ret

    def _dist(self, s):
        """
        :param int s:
        :rtype: list of int
        :return: s からの距離。残余グラフ上で到達できない場合は -1
        """
        ret = [-1] * len(self.graph)
        ret[s] = 0
        # PyPy で deque 遅いのでリストで
        vd = [(s, 0)]
        while vd:
            next_vd = []
            for v, d in vd:
                for u, cap, _ in self.graph[v]:
                    if ret[u] < 0 < cap:
                        ret[u] = d + 1
                        next_vd.append((u, d + 1))
            vd = next_vd
        return ret

    def _dfs(self, s, t, dist, iter, flow=float('inf')):
        """
        :param int s:
        :param int t:
        :param list of int dist:
        :param list of int iter:
        :param int flow:
        """
        if s == t:
            return flow
        while iter[s] < len(self.graph[s]):
            edge = self.graph[s][iter[s]]
            to, cap, rev = edge
            if dist[s] < dist[to] and cap > 0:
                f = self._dfs(to, t, dist, iter, min(flow, cap))
                if f > 0:
                    edge[1] -= f
                    rev[1] += f
                    return f
            iter[s] += 1
        return 0

    def maximum_flow(self, from_v, to_v):
        """
        :param int from_v: 
        :param int to_v: 
        :return: from_v から to_v への最大流
        """
        ret = 0
        while True:
            dist = self._dist(from_v)
            if dist[to_v] < 0:
                break
            iter = [0] * len(self.graph)
            while True:
                f = self._dfs(from_v, to_v, dist, iter)
                if f == 0:
                    break
                ret += f
        return ret


N = int(sys.stdin.readline())
AB = [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
CD = [list(map(int, sys.stdin.readline().split())) for _ in range(N)]

S = N * 2
T = N * 2 + 1

graph = [[] for _ in range(N * 2 + 2)]
for i, (a, b) in enumerate(AB):
    for j, (c, d) in enumerate(CD):
        if a < c and b < d:
            graph[i].append((j + N, 1))
for i in range(N):
    graph[S].append((i, 1))
for i in range(N):
    graph[i + N].append((T, 1))

print((Dinic(graph=graph).maximum_flow(S, T)))