Go: package main

import (
	"bufio"
	"os"
	"strconv"
	"strings"
	"sort"
	"fmt"
)

var scanner = bufio.NewScanner(os.Stdin)

func main() {
	for scanner.Scan() {
		n, _ := strconv.Atoi(scanner.Text())
		if n == 0 {
			break
		}
		hr := make([]entry, 0)
		for i := 0; i < n; i++ {
			scanner.Scan()
			buf := strings.Split(scanner.Text(), " ")
			first, _ := strconv.Atoi(buf[0])
			second, _ := strconv.Atoi(buf[1])
			mt := entry{first, second}
			hr = append(hr, mt)
		}
		scanner.Scan()
		m, _ := strconv.Atoi(scanner.Text())
		for i := 0; i < m; i++ {
			scanner.Scan()
			buf := strings.Split(scanner.Text(), " ")
			first, _ := strconv.Atoi(buf[0])
			second, _ := strconv.Atoi(buf[1])
			mt := entry{first, second}
			hr = append(hr, mt)
		}
		sort.Sort(ByFirst(hr))
		fmt.Println(LIS(hr))
	}
}

type entry struct {
	first, second int
}

type ByFirst []entry

func(f ByFirst) Len() int {
	return len(f)
}

func (f ByFirst) Swap(i, j int) {
	f[i], f[j] = f[j], f[i]
}

func (f ByFirst) Less(i, j int) bool {
	return f[i].first < f[j].first
}

func LIS(hr []entry) int {
	n := len(hr)
	lis := make([]int, n)
	lis[n-1] = 1
	for i := n-2; i > -1; i-- {
		m := 0
		for j := i+1; j < n; j++ {
			if hr[i].first < hr[j].first && hr[i].second < hr[j].second && lis[j] > m {
				m = lis[j]
			}
		}
		lis[i] = m+1
	}
	return lis[0]
}

C++: #include <bits/stdc++.h>

#define FOR(i,a,b) for(int i= (a); i<((int)b); ++i)
#define RFOR(i,a) for(int i=(a); i >= 0; --i)
#define FOE(i,a) for(auto i : a)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define DUMP(x)  cerr << #x << " = " << (x) << endl;
#define SUM(x) std::accumulate(ALL(x), 0LL)
#define MIN(v) *std::min_element(v.begin(), v.end())
#define MAX(v) *std::max_element(v.begin(), v.end())
#define EXIST(v,x) (std::find(v.begin(), v.end(), x) != v.end())
#define BIT(n) (1LL<<(n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());

typedef long long LL;
template<typename T> using V = std::vector<T>;
template<typename T> using VV = std::vector<std::vector<T>>;
template<typename T> using VVV = std::vector<std::vector<std::vector<T>>>;

template<class T> inline T ceil(T a, T b) { return (a + b - 1) / b; }
template<class T> inline void print(T x) { std::cout << x << std::endl; }
template<class T> inline void print_vec(const std::vector<T> &v) { for (int i = 0; i < v.size(); ++i) {  if (i != 0) {std::cout << " ";} std::cout << v[i];} std::cout << "\n"; }
template<class T> inline bool inside(T y, T x, T H, T W) {return 0 <= y and y < H and 0 <= x and x < W; }
template<class T> inline double euclidean_distance(T y1, T x1, T y2, T x2) { return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); }
template<class T> inline double manhattan_distance(T y1, T x1, T y2, T x2) { return abs(x1 - x2) + abs(y1 - y2); }

const int INF = 1L << 30;
const double EPS = 1e-9;
const std::string YES = "YES", Yes = "Yes", NO = "NO", No = "No";
const std::vector<int> dy4 = { 0, 1, 0, -1 }, dx4 = { 1, 0, -1, 0 };    // 4近傍（右, 下, 左, 上）
const std::vector<int> dy8 = { 0, -1, 0, 1, 1, -1, -1, 1 }, dx8 = { 1, 0, -1, 0, 1, 1, -1, -1 };

using namespace std;

int main() {
    cin.tie(0);
	ios::sync_with_stdio(false);

	while (true) {
	    int N , M;
	    cin >> N;
	    if (N == 0) {
	        break;
	    }
	    vector<pair<int, int>> m;
	    FOR(i, 0, N) {
	        int h, r;
	        cin >> h >> r;
	        m.emplace_back(make_pair(h, r));
	    }
	    cin >> M;
        FOR(i, 0, M) {
            int h, r;
            cin >> h >> r;
            m.emplace_back(make_pair(h, r));
        }

        vector<vector<int>> dp(1001, vector<int>(1001, -1));
        dp[0][0] = 0;

        FOR(j, 0, dp.size()) {
            FOR(k, 0, dp[0].size()) {
                if (dp[j][k] == -1) {
                    continue;
                }
                FOR(i, 0, m.size()) {
                    int h = m[i].first;
                    int r = m[i].second;

                    if (j < h and k < r) {
                        dp[h][r] = max(dp[h][r], dp[j][k] + 1);
                    }
                }
            }
        }

        int ans = 0;
        FOR(j, 0, dp.size()) {
            FOR(k, 0, dp[0].size()) {
                ans = max(ans, dp[j][k]);
            }
        }

        print(ans);
	}

	return 0;
}

C++: #include<iostream>
#include<vector>
#include<algorithm>

typedef std::pair<int, int> P;

P data[202];
int dp[202];

int main(){

	int n, m;
	while (std::cin >> n, n){

		data[0] = P(0, 0);
		dp[0] = 0;
		for (int i = 1; i <= n; i++){
			std::cin >> data[i].first >> data[i].second;
		}

		std::cin >> m;
		for (int i = 1; i <= m; i++){
			std::cin >> data[i + n].first >> data[i + n].second;
		}

		std::sort(data, data + 1 + n + m);

		for (int i = 1; i <= n + m; i++){
			for (int j = 0; j < i; j++){
				if (data[i].first > data[j].first&&data[i].second > data[j].second){
					dp[i] = dp[j] + 1;
				}
			}
		}

		int max = 0;
		for (int i = 0; i <= n + m; i++){
			if (dp[i] > max)max = dp[i];
		}
		std::cout << max << std::endl;
	}
	return 0;
}

C++: #include<iostream>
#define NUM 1000
using namespace std;

int main(){
	while(1){
		bool dp[NUM][NUM] = {false};
		int n, m, h, r, ans = 0;
		cin >>n;
		if(n == 0) break;
		for(int i = 0; i < n; i++){
			cin >>h >>r;
			dp[h][r] = true;
		}
		cin >>m;
		for(int i = 0; i < m; i++){
			cin >>h >>r;
			dp[h][r] = true;
		}
		int cnt = 1;
		for(int i = cnt; i < NUM; i++){
			for(int j = cnt; j < NUM; j++){
				if(dp[i][j] == true){
					ans++;
					cnt = j + 1;
					break;
				}
			}
		}
		cout <<ans <<endl;
	}
	return 0;
}

C++: #include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <string>
#include <vector>
#include <queue>
#include <list>
#include <map>

using namespace std;

#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)
#define SUPAML 101
#define SUPBML 101

struct M{
	int h, r, i;
	bool operator<(const M& m) const{
		return h<m.h;
	}
};

int aml,bml;
int ml;
M ams[SUPAML],bms[SUPBML];
M ms[SUPAML+SUPBML];
int rs[SUPAML+SUPBML];

int main(){
	while(true){
		cin >> aml;			if(!aml) return 0;
		FOR(ami,0,aml){
			int h,r;
			cin >> h >> r;
			ams[ami].h=h; ams[ami].r=r;
		}
		cin >> bml;
		FOR(bmi,0,bml){
			int h,r;
			cin >> h >> r;
			bms[bmi].h=h; bms[bmi].r=r;
		}
		
		ml = aml+bml;
		FOR(ami,0,aml) ms[ami]=ams[ami];
		FOR(bmi,0,bml) ms[aml+bmi]=bms[bmi];
		sort(ms,ms+ml);

		int ret=0;
		fill(rs,rs+ml,1);
		FOR(mi,0,ml){	M m=ms[mi];
			FOR(ni,0,mi){	M n=ms[ni];
				if(n.h<m.h&&n.r<m.r) rs[mi] = max(rs[mi],rs[ni]+1);
			}
			ret = max(ret,rs[mi]);
		}


		cout << ret << endl;
	}
}

C++: #include <vector>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <cstring>
#include <deque>
#include <cstdio>
#include <cmath>
#include <complex>
#include <iostream>
#include <iterator>

using namespace std;

#define reep(i,f,t) for(int i=f ; i<int(t) ; ++i)
#define rep(i,n) reep(i, 0, n) 

typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;

const int INF = 10000000;
int main()
{
	int n;
	while(scanf("%d", &n), n){
		vector<pii> doll(n);
		rep(i, n){
			scanf("%d%d", &doll[i].first, &doll[i].second);
			doll[i].first *= -1;
		}
		
		int m;
		scanf("%d", &m);
		doll.resize(n+m);
		rep(i, m){
			scanf("%d%d", &doll[n+i].first, &doll[n+i].second);
			doll[n+i].first *= -1;
		}
		
		sort(doll.begin(), doll.end(), greater<pii>());
		vi dp(n+m, INF);
		rep(i, n+m){
			int id = distance(dp.begin(), lower_bound(dp.begin(), dp.end(), doll[i].second));
			dp[id] = doll[i].second;
		}
		
		int ans;
		for(int i=n+m-1; i>=0; --i){
			if(dp[i] != INF){
				ans = i + 1;
				break;
			}
		}
		
		printf("%d\n", ans);
	}
	
	return 0;
}