using System;
using System.Collections;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Collections.Generic;
using System.Threading.Tasks;

/*
・概要
：MaxFlowAlgorithmのアルゴリズムを使用し、（重みなし）最大二部マッチング問題を解くライブラリ。
	（最大流問題に使用するアルゴリズムを応用）
	より高速で動く。

：最大流を求める計算量は、O(V * E^2)　or　O(V^2 * E)
	（※正確には未確認）
	なお、事前準備の段階でO(X + Y)かかる。
	（X,Yは二集団それぞれの要素数。）

・（最大）二部マッチング問題とは。
：最大二部マッチング
	「二集団間で最大何ペア作ることができるか」、という問題。
	（ペア作成可能）条件を満たすペアの間にだけ、有向辺を追加し、
	後は最大流問題として解くだけ。

：重み付き最大二部マッチング
	上記に加え、ペア毎に異なる利得が得られる場合に、
	「全ペアの合計利得の最大値」を求める問題。
	→「最小費用流」問題に帰着可能（本ライブラリの対象外）

：最大流問題を応用した解法
	二集団の前後にノード（スタートとゴール）を付け加えることで、最大流問題に帰着可能
	（cf. 重みづけがないので、フローを全て1にすれば良いだけ）

・使用法
1. 名前空間MaxFlowAlgorithm上のクラスMatchingのインスタンスを作成
	引数は、２集団X,Yそれぞれの要素数（頂点の数）
	（e.g. MaxFlowAlgorithm.Matching match = new MaxFlowAlgorithm.Matching(X,Y);）

2. MatchPair関数で、マッチング可能な二者間全ての間に、辺を形成する。
	引数は、集団Xの頂点と、集団Yの頂点。
	（e.g. match.MatchPair(x,y);）
	なお、それぞれ「Xの中で何番目か」、「Yの中で何番目か」を渡せば良い。

3. MaxPair関数で、最大マッチング数を取得する。
	（e.g. int ans = match.MaxPair();）

*/

class Program
{
	//Main
	static void Main(string[] args)
	{
		//読み込む
		int N = int.Parse(Console.ReadLine());

		//それぞれの座標を読み込む
		int[][] red = new int[N][];
		int[][] blue = new int[N][];
		for(int i=0; i<N; i++){
			red[i] = Console.ReadLine().Split(' ').Select(j => int.Parse(j)).ToArray();
		}
		for(int i=0; i<N; i++){
			blue[i] = Console.ReadLine().Split(' ').Select(j => int.Parse(j)).ToArray();
		}

		//1. 名前空間MaxFlowAlgorithm上のクラスMatchingのインスタンスを作成
		//引数は、２集団X,Yそれぞれの要素数（頂点の数）
		MaxFlowAlgorithm.Matching match = new MaxFlowAlgorithm.Matching(N,N);

		//2. マッチング可能な二者間全ての間に、辺を形成する。
		for(int i=0; i<N; i++){
			for(int j=0; j<N; j++){
				if(red[i][0] < blue[j][0] && red[i][1] < blue[j][1]){
					match.MatchPair(i,j);
				}
			}
		}

		//MaxPair関数で、最大マッチング数を取得する。
		int ans = match.MaxPair();

		Console.WriteLine(ans);
	}
}

//MaxFlowAlgorithm法用の名前空間
/*
3つのクラスを内包
・（重みなし）最大二部マッチング問題を解く為のクラスMatching
・辺を意味するEdge
・グラフとして問題を解くGraph
*/

/*
全てclass Graphからアクセスのこと
（e.g.
・初期化
	MaxFlowAlgorithm.Graph maxPair = new MaxFlowAlgorithm.Graph(N+N+2);

・エッジの追加
	maxPair.AddEdge(start,goal,1);
）
*/

namespace MaxFlowAlgorithm
{
	//最大二部マッチング問題を解く為のクラス
	class Matching
	{
		//マッチング問題を解くのに使うGraph
		private Graph graph;
		//集団X、集団Yそれぞれの数
		private int X;
		private int Y;
		//graphの要素数
		private int len;

		//コンストラクタ
		/*
		引数は、集団1、集団2それぞれの要素数（頂点の数）
		（e.g. 男女でペアを作る場合、男子の数と女子の数）
		*/
		public Matching(int x, int y)
		{
			//要素数を設定
			this.X = x;
			this.Y = y;

			//graphを初期化
			//1. インスタンスを作成
			//ノード数は、両集団の構成員数＋２（スタートとゴール）
			this.len = X + Y + 2;
			this.graph = new Graph(len);

			//2. スタートと集団Xとの間、集団Yとゴールとの間に、それぞれ辺を作成
			this.Initialize();
		}

		//graphを初期化する関数（計算量O（X + Y））
		/*
		スタートと集団Xとの間、集団Yとゴールとの間に、それぞれ辺を作成。
		これにより、スタートからゴールまでの経路が作成可能なようにする。
		（重みは全て1で良い。スタート・ゴールと結んだ辺の数を、ペア数が超えることはない。）
		*/
		private void Initialize()
		{
			/*
			スタート、ゴールのノード番号はそれぞれ、
			要素数の末尾2つとする。（len-2, len-1）
			*/
			int start = this.len-2;
			int goal = this.len-1;

			//集団Xの全要素をスタートに結合
			for(int i=0; i<this.X; i++){
				/*
				集団Xのノード番号は、そのままiを使う
				（i：集団X内で何番目か）
				*/
				this.graph.AddEdge(start,i,1);
			}

			//集団Yの全要素をゴールに結合
			for(int i=0; i<this.Y; i++){
				/*
				集団Yのノード番号は、i+Xとなる
				（i：集団Y内で何番目か）
				*/
				this.graph.AddEdge(i+this.X,goal,1);
			}
		}

		//マッチング可能なペアの間に、辺を形成する関数
		/*
		引数は、
		1.集団Xの中の何番目の要素か、
		2.集団Xの中の何番目の要素か、
		*/
		public void MatchPair(int elemX, int elemY)
		{
			//両者の間に辺を結ぶ
			/*
			集団Xのノード番号は、そのままelemXを使う。
			集団Yのノード番号は、elemY+Xとなる
			*/
			this.graph.AddEdge(elemX,elemY+this.X,1);
		}

		//最大マッチング数を返す関数
		public int MaxPair()
		{
			//スタートからゴールまでの最大流を返せば良い
			int start = this.len-2;
			int goal = this.len-1;
			return this.graph.MaxFlow(start,goal);
		}
	}

	public class Graph
	{
    public readonly List<Edge>[] G;
    readonly int[] lv, iter;

		//コンストラクタ
		/*
		全体のノード数で初期化
		*/
    public Graph(int V)
    {
      G = new List<Edge>[V];
      lv = new int[V];
      iter = new int[V];
      for (int i = 0; i < G.Length; i++)
          G[i] = new List<Edge>();
    }

		//辺を追加
		/*
		引数：出発点、行き先、重み（その辺の最大流）
		（＝始点、終点、フロー）
		*/
    public void AddEdge(int from, int to, int cap)
    {
      addEdge(from, to, cap, 0);
    }

    public void AddUndirectedEdge(int from, int to, int cap)
    {
      addEdge(from, to, cap, cap);
    }

		//辺を繋ぐサブメソッド
    void addEdge(int f, int t, int c1, int c2)
    {
      var a = new Edge(t, c1);
      var b = new Edge(f, c2);
      Edge.Link(a, b);
      G[f].Add(a);
      G[t].Add(b);
    }

		//最大流を返す
		/*
		引数：出発点と行き先（スタートとゴール）
		*/
    public int MaxFlow(int src, int sink, int f = -1)
    {
      int flow = 0;
      if (f < 0) f = int.MaxValue;
      while (f > 0)
      {
        bfs(src);
        if (lv[sink] == 0) return flow;
        Array.Clear(iter, 0, iter.Length);
        int df;
        while ((df = dfs(src, sink, f)) > 0) { flow += df; f -= df; }
      }
      return flow;
    }

    void bfs(int s)
    {
      Array.Clear(lv, 0, lv.Length);
      var q = new Queue<int>();
      lv[s] = 1;
      q.Enqueue(s);
      while (q.Count > 0)
      {
        var v = q.Dequeue();
        foreach (var e in G[v])
            if (e.Cap > 0 && lv[e.To] == 0)
            {
              lv[e.To] = lv[v] + 1;
              q.Enqueue(e.To);
            }
      }

    }
    int dfs(int v, int t, int f)
    {
      if (v == t) return f;
      int ret = 0;
      for (; iter[v] < G[v].Count; iter[v]++)
      {
        var e = G[v][iter[v]];
        if (e.Cap <= 0 || lv[v] >= lv[e.To]) continue;
        int df = dfs(e.To, t, Math.Min(f, e.Cap));
        if (df <= 0) continue;
        e.Cap -= df;
        e.Rev.Cap += df;
        ret += df; f -= df;
        if (f == 0) break;
      }
      return ret;

    }
	}

	//辺
	public class Edge
	{
    public static void Link(Edge e1, Edge e2)
    {
      e1.Rev = e2; e2.Rev = e1;
    }
    public int To { get; private set; }
    public Edge Rev { get; private set; }
    public int Cap { get; set; }
    public Edge(int t, int c)
    {
      To = t;
      Cap = c;
    }
    public override string ToString()
    {
      return string.Format("to: {0}, cap: {1}", To, Cap);
    }
	}
}



Measured memory_bytes: 19300