/*
Author: Yiu Yu Ho

This is a binary search problem.  The following describes a O(n (log(n) + log(m))) solution:

For x=K streets (vertical streets)
(1) sort streets by x-value, increasing
(2) sort points: first by y value (any fixed order), then by x-value (increasing)
(3) for each distinct y-value of the points, obtain the sorted (by x) set of points 
    with the same y value.
(4) for each point, use binary search to find the street to the left (lower bound) 
    and right (upper bound) of the point.
(5) check to see if the point is viewable from those streets by checking whether 
    it is blocked by the point to its left/right.

Perform similar checks for y=K streets (horizontal streets)
Count the number of points that are marked viewable
*/

import java.util.*;
import java.io.*;

public class park
{
	public BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	public PrintStream out = System.out;

	public int n,m;
	public Tree[] v;
	public int[] xv,yv;

	public void main()
	{
		try
		{
			String L=in.readLine();
			StringTokenizer tok=new StringTokenizer(L);

			n=new Integer(tok.nextToken());
			m=new Integer(tok.nextToken());
			
			while(n>0)
			{
				int i,j,k;
				
				v=new Tree[n];
				for(i=0;i<n;++i)
				{
					L=in.readLine();
					tok=new StringTokenizer(L);
					v[i]=new Tree(new Integer(tok.nextToken()),new Integer(tok.nextToken()));
				}
				
				ArrayList XA=new ArrayList<Integer>();
				ArrayList YA=new ArrayList<Integer>();

				for(i=0;i<m;++i)
				{
					L=in.readLine();
					if(L.charAt(0)=='x')
					{
						XA.add(new Integer(L.substring(2)));
					}
					else
					{
						YA.add(new Integer(L.substring(2)));
					}
				}

				xv=IAL2ia(XA);
				yv=IAL2ia(YA);
				
				int a,b,c;

				if(xv.length>0)
				{
					Arrays.sort(xv);
					Arrays.sort(v,new CYX());

					i=0;
					while(i<n)
					{
						j=i;
						while(j+1<n && v[j+1].y==v[i].y) ++j;

						for(k=i;k<=j;++k)
						{
							if(v[k].x>xv[0])
							{
								a=lower(xv,v[k].x);
								if(k==i || v[k-1].x<xv[a]) v[k].seen=true;
							}
							if(v[k].x<xv[xv.length-1])
							{
								b=upper(xv,v[k].x);
								if(k==j || v[k+1].x>xv[b]) v[k].seen=true;
							}
						}

						i=j+1;
					}
				}//end if xv.length>0
				
				if(yv.length>0)
				{
					Arrays.sort(yv);
					Arrays.sort(v,new CXY());
					i=0;
					while(i<n)
					{
						j=i;
						while(j+1<n && v[j+1].x==v[i].x) ++j;

						for(k=i;k<=j;++k)
						{
							if(v[k].y>yv[0])
							{
								a=lower(yv,v[k].y);
								if(k==i || v[k-1].y<yv[a]) v[k].seen=true;
							}
							if(v[k].y<yv[yv.length-1])
							{
								b=upper(yv,v[k].y);
								if(k==j || v[k+1].y>yv[b]) v[k].seen=true;
							}
						}
						i=j+1;
					}
				}//end if yv.length>0

				int R=0;
				for(i=0;i<n;++i) if(v[i].seen) ++R;
				out.println(R);

				L=in.readLine();
				tok=new StringTokenizer(L);

				n=new Integer(tok.nextToken());
				m=new Integer(tok.nextToken());
			}//end while n>0
		}
		catch(IOException ioe)
		{
			ioe.printStackTrace();
		}
	}

	public int lower(int[] v,int key)
	{
		int low,hi,x;
		low = 0; hi=v.length-1;
		while(low<hi)
		{
			x=(low+hi+1)/2;
			if(v[x]<key) low=x;
			else hi=x-1;
		}
		return low;
	}

	public int upper(int[] v,int key)
	{
		if(v[0]>key) return 0;
		return lower(v,key)+1;
	}

	public int[] IAL2ia(ArrayList<Integer> A)
	{
		int[] r=new int[A.size()];
		for(int i=0;i<r.length;++i) r[i]=A.get(i);
		return r;
	}

	private class CYX implements Comparator<Tree>
	{
		public int compare(Tree A,Tree B)
		{
			if(A.y!=B.y) return A.y<B.y?-1:1;
			if(A.x!=B.x) return A.x<B.x?-1:1;
			return 0;
		}
	}

	private class CXY implements Comparator<Tree>
	{
		public int compare(Tree A,Tree B)
		{
			if(A.x!=B.x) return A.x<B.x?-1:1;
			if(A.y!=B.y) return A.y<B.y?-1:1;
			return 0;
		}
	}

	private class Tree
	{
		public int x,y;
		public boolean seen;

		public Tree(int xx,int yy) { x=xx; y=yy; seen=false; }
	}

	public static void main(String[] args) 
	{
		long startTime = System.currentTimeMillis();
		(new park()).main();
		System.err.println("Time = "+(System.currentTimeMillis()-startTime)+"(ms)");
	}
}