#include <iostream>
#include <vector>

using namespace std;
struct my_point{
  int row;
  int col;
};

// Is icon with upper left (r,c) inside box with upper left (x1,y1) and 
// lower right (x2,y2)?
bool Inside(int r, int c, int x1, int y1, int x2, int y2){
  double real_r = r + 4.5;
  double real_c = c + 7.5;
  if(real_r < x1 || real_r > x2)
    return false;
  if(real_c < y1 || real_c > y2)
    return false;
  return true;
}


void Swap(int& x, int& y){
  int temp = x;
  x = y;
  y = temp;
}

void Sort(vector<int>& v){
  for(int i = 0; i < v.size(); i++)
    for(int j = 0; j < v.size()-1; j++)
      if(v[j] > v[j+1])
	Swap(v[j], v[j+1]);
}

void Setup_Relavent_R(const vector<my_point>& keep_list,  const vector<my_point>& del_list,   vector<int>& relavent_r){
  for(int i = 0; i < keep_list.size(); i++){
    relavent_r.push_back(keep_list[i].row+4);
  
  }
  for(int i = 0; i < del_list.size(); i++){
    relavent_r.push_back(del_list[i].row+4);
  
  }
  
  Sort(relavent_r);
}

void Setup_Relavent_C(const vector<my_point>& keep_list,  const vector<my_point>& del_list,   vector<int>& relavent_c){
  for(int i = 0; i < keep_list.size(); i++){
    relavent_c.push_back(keep_list[i].col+7);
  
  }
  for(int i = 0; i < del_list.size(); i++){
    relavent_c.push_back(del_list[i].col+7);
  
  }
  Sort(relavent_c);
}

			 
// "Grid" will contain the # of items in "list" that are located to the upper left

void Setup_Grid(const vector<my_point>& list, const vector<int>& relavent_r, const vector<int>& relavent_c, vector<vector<int> >& grid){
  for(int i = 0; i < grid.size(); i++)
    for(int j = 0; j < grid[i].size(); j++){
      for(int k = 0; k < list.size(); k++){
	int i_pos = relavent_r[i];
	int j_pos = relavent_c[j];
	double real_r = list[k].row + 4.5;
	double real_c = list[k].col + 7.5;
	if(real_r < i_pos && real_c < j_pos)
	  grid[i][j]++;
      }
    }
}

int Solve(const vector<my_point>& del_list, const vector<my_point>& keep_list, const vector<vector<int> >& del_grid, const vector<vector<int> >& keep_grid, const vector<int>& relavent_r, const vector<int>& relavent_c, int r, int c){
  int best_moves = del_list.size() + keep_list.size();
  for(int i = 0; i < relavent_r.size(); i++){
    for(int j = 0; j < relavent_c.size(); j++){
      for(int k = i+1; k < relavent_r.size(); k++){
	for(int l = j+1; l < relavent_c.size(); l++){
	  // how many moves for a box with upper left (i,j) and
	  // lower right (k,l)?
	  int del_inside = del_grid[k][l]- del_grid[k][j] - del_grid[i][l] + del_grid[i][j];
	  int keep_inside = keep_grid[k][l] - keep_grid[k][j] - keep_grid[i][l] + keep_grid[i][j];
	  int num_moves = del_list.size()-del_inside + keep_inside;
	  if(num_moves < best_moves)
	    best_moves = num_moves;
	}
      }
    }
  }
  return best_moves;
}

	    

int main(){
    int r,c,bobs_adjustment=0;
    cin >> r >> c;
    int num_del;
    cin >> num_del;
    int num_keep;
    cin >> num_keep;
    vector<my_point> del_list;
    for(int i = 0; i < num_del; i++){
      my_point p;
      cin >> p.row;
      cin >> p.col;
      if (p.row > r - 8 || p.col > c - 4)
        bobs_adjustment++;
      else
        del_list.push_back(p);
    }
    vector<my_point> keep_list(num_keep);
    for(int i = 0; i < num_keep; i++){
      cin >> keep_list[i].row;
      cin >> keep_list[i].col;
    }


    vector<int> relavent_r;
    vector<int> relavent_c;
    Setup_Relavent_R(keep_list, del_list, relavent_r);
    relavent_r.push_back(r+9);
    Setup_Relavent_C(keep_list, del_list, relavent_c);
    relavent_c.push_back(c+15);
    vector<vector<int> > del_grid(relavent_r.size()); 
    vector<vector<int> > keep_grid(relavent_r.size());
    for(int i = 0; i < relavent_r.size(); i++){
      del_grid[i].resize(relavent_c.size(),0);
      keep_grid[i].resize(relavent_c.size(),0);
    }    
    Setup_Grid(del_list, relavent_r, relavent_c, del_grid);
    Setup_Grid(keep_list, relavent_r, relavent_c, keep_grid);
    int num_moves = Solve(del_list,keep_list,del_grid, keep_grid, relavent_r, relavent_c, r, c);
    cout << num_moves + bobs_adjustment << endl;
    // cout << relavent_r.size() << endl;
  
  return 0;
}