2 2
0 0
30 9
6 2
19 2
 1 1
1000000000 1000000000
1000000000 1000000000
 20 20
19 1
67 10
42 0
185 1
68 2
88 0
74 3
138 2
30 5
112 8
1 1
137 0
125 0
106 5
145 0
188 2
166 11
49 1
171 5
15 0
166 1
171 1
29 1
190 1
76 1
146 1
84 1
169 1
58 1
111 1
81 1
33 1
144 1
182 0
44 0
63 1
176 1
68 1
184 1
147 1
 20 20
87 2
77 3
88 5
54 3
49 1
114 1
103 0
173 0
126 0
28 6
144 6
191 6
14 4
44 4
19 1
165 9
5 1
183 3
113 9
147 3
47 1
45 0
34 1
191 0
199 1
154 1
163 1
142 0
54 1
136 1
167 1
151 1
166 1
108 1
79 1
172 0
76 1
74 1
31 1
95 1
 10 10
33 2
922 34
480 105
844 5
739 39
325 20
999 88
462 104
225 5
93 4
13 15
323 9
152 20
785 11
512 4
859 8
327 14
818 9
794 13
99 20
 20 20
71 3
168 4
112 2
49 3
140 0
32 1
17 1
9 1
180 2
84 0
47 2
134 0
58 1
75 1
0 3
107 7
161 6
143 3
183 5
121 4
190 1
140 1
83 0
174 0
192 1
119 0
164 1
79 1
31 1
17 1
125 1
18 1
136 0
115 1
133 1
40 0
181 1
25 1
114 1
113 1
 2 2
0 19
29 6
5 3
17 3
 2 2
1 6
26 24
20 2
1 2
 2 2
9 1
0 19
17 3
18 3
 2 2
32 0
0 9
14 2
10 3
 2 2
0 11
19 9
8 2
16 2
 2 2
23 3
5 4
1 3
11 3
 20 20
52 0
126 2
197 1
28 4
69 2
88 7
78 3
105 1
157 2
143 0
16 4
182 6
104 10
171 2
36 1
64 7
0 3
118 1
13 0
153 0
185 1
164 1
51 1
0 1
48 0
147 1
162 1
96 1
5 1
190 1
127 1
79 0
62 1
63 1
29 1
181 1
137 1
42 1
80 1
181 1
 2 2
0 1
28 18
9 2
2 1
 20 20
76 3
136 2
58 3
18 9
1 2
123 6
186 2
163 2
6 1
73 3
91 4
37 2
141 6
103 0
26 5
155 0
52 0
174 0
187 8
104 7
33 1
173 1
138 1
2 1
106 1
155 1
101 0
168 1
114 1
98 0
72 1
120 1
43 1
73 1
25 1
183 1
177 0
54 1
179 1
131 1
 2 2
0 16
15 12
5 2
8 3
 20 20
177 4
62 0
45 7
190 0
134 0
49 0
158 6
71 0
113 3
106 4
152 1
103 0
27 2
76 1
28 1
10 8
0 0
173 9
135 10
94 3
15 1
33 1
122 1
136 1
17 1
85 1
95 1
41 1
133 1
136 0
150 1
126 1
21 1
200 1
102 0
177 1
89 1
161 1
178 1
114 1
 20 20
150 4
138 3
95 0
25 1
80 0
72 3
127 7
29 1
153 5
174 4
197 1
170 4
104 0
11 1
41 4
67 4
48 5
119 3
94 6
6 3
25 0
91 1
18 0
120 1
45 1
177 1
80 1
174 1
136 1
182 1
97 1
116 1
114 1
119 1
114 1
46 1
31 1
186 1
123 1
169 1
 20 20
77 6
0 3
68 1
25 4
179 5
27 0
187 0
159 4
11 2
53 1
107 3
106 0
48 7
150 3
131 4
171 5
43 2
124 5
136 3
90 5
153 1
75 1
178 1
1 0
148 1
19 1
15 1
116 1
174 1
191 1
80 0
44 1
122 1
136 1
35 1
11 1
40 0
7 1
186 1
191 1
 2 2
34 1
0 5
2 2
19 0
 20 20
81 6
77 2
22 1
155 3
94 0
110 2
11 5
116 2
156 5
167 2
31 3
47 5
3 4
194 3
177 6
83 0
124 10
48 0
147 0
64 3
88 0
146 1
66 1
82 1
167 1
53 1
161 1
177 1
187 0
40 1
182 0
128 1
172 1
155 0
157 1
166 1
96 1
146 1
36 1
125 1
 20 20
19 5
186 3
32 3
46 2
74 2
114 1
162 3
3 8
87 3
101 0
4 1
127 0
157 6
128 8
147 3
189 1
52 11
61 1
175 0
70 2
65 1
143 1
82 1
110 1
162 1
150 1
29 1
4 1
186 1
132 1
166 1
183 1
44 1
59 1
192 1
146 1
83 1
140 1
75 1
101 1

0 0
0 9
 1 2000000000
 0 1
2 12
0 0
0 1
0 2
0 0
0 3
0 2
1 6
0 8
0 1
0 0
0 0
1 6
0 0
1 3
4 15
0 1
0 5
0 0
 0 2
1 4
0 5
1 4
0 1
0 1
0 0
0 0
0 0
2 8
0 6
1 6
0 4
2 5
0 1
3 11
0 1
0 3
0 9
0 3
 0 2
0 34
0 105
0 5
0 39
1 34
0 88
1 108
0 5
0 4
 0 3
0 4
0 2
0 3
1 1
0 1
2 3
0 1
1 3
0 0
0 2
0 0
0 1
0 1
0 3
3 10
1 7
0 3
0 5
1 5
 2 25
0 6
 1 8
0 24
 0 1
2 25
 0 0
0 9
 1 13
0 9
 0 3
0 4
 0 0
1 3
0 1
1 5
0 2
0 7
2 4
0 1
0 2
0 0
0 4
1 7
0 10
0 2
0 1
0 7
1 4
0 1
0 0
0 0
 0 1
0 18
 0 3
1 3
0 3
1 10
1 3
0 6
0 2
0 2
0 1
1 4
0 4
0 2
0 6
0 0
0 5
1 1
0 0
0 0
0 8
1 8
 2 21
0 12
 0 4
0 0
0 7
0 0
0 0
0 0
1 7
0 0
1 4
0 4
0 1
0 0
0 2
0 1
0 1
2 10
0 0
2 11
2 11
1 4
 0 4
0 3
0 0
1 1
1 1
0 3
0 7
0 1
0 5
1 5
0 1
1 5
0 0
0 1
2 6
0 4
0 5
3 6
1 7
0 3
 1 6
1 3
0 1
0 4
0 5
0 0
0 0
0 4
1 3
0 1
0 3
0 0
0 7
1 4
0 4
1 6
1 3
0 5
1 4
0 5
 0 1
1 7
 2 7
0 2
0 1
2 4
0 0
0 2
0 5
0 2
1 6
1 3
0 3
0 5
0 4
0 3
2 7
0 0
2 12
0 0
0 0
1 4
 0 5
1 4
0 3
0 2
1 3
0 1
0 3
1 9
0 3
1 1
0 1
0 0
1 7
1 9
1 4
0 1
1 12
0 1
0 0
0 2

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



 
public class mymy
{
    static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;
 
		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream), 32768);
			tokenizer = null;
		}
 
		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}
 
		public int nextInt() {
			return Integer.parseInt(next());
		}
		public long nextLong() {
			return Long.parseLong(next());
		}
 
}
	static OutputStream outputStream = System.out;
	static PrintWriter out = new PrintWriter(outputStream);	
	static InputStream inputStream = System.in;
	static InputReader br = new InputReader(inputStream);
	
	static long Pinf=(long)Double.POSITIVE_INFINITY;
	static node4pos[] pos;
	
 
	static class Postree
	{
		int size;nodeTreePos[] arr;
		Postree(int n)
		{
			size=2*((int)Math.pow(2,(int)Math.ceil(Math.log(n)/Math.log(2))))-1;
			arr=new nodeTreePos[size];
		}
 
		void build()
		{
			int j=0;int leaves=(size-1)/2;int k=0;
			for(int i=leaves;i<size&&j<pos.length;i++)
			{
				arr[i]=new nodeTreePos(pos[j].start,pos[j].end);arr[i].indx=pos[j].indx;
				j++;k=i;
			}
			for(int i=k+1;i<size;i++)
				arr[i]=new nodeTreePos(Pinf,Pinf);
			for(int i=leaves-1;i>=0;i--)
			{
				long s=(long)Math.min(arr[2*i+1].start,arr[2*i+2].start),e=(long)Math.max(arr[2*i+1].end,arr[2*i+2].end);
				arr[i]=new nodeTreePos(s,e);
			}
		}
		void update(int check)
		{
			if(size<=1)
				return;
			int par=(check-1)/2;
			while(true)
			{
				//System.out.println("2");
				arr[par].start=(long)Math.min(arr[2*par+1].start,arr[2*par+2].start);
				arr[par].end=(long)Math.max(arr[2*par+1].end,arr[2*par+2].end);	/////// agar TLE... come here again
				if(par==0)
					break;
				par=(par-1)/2;
			}
		}
		int find(long p,int pos)
		{
			if(arr[pos].start>p||arr[pos].end<p)
				return -1;
			else if(arr[pos].start<=p&&arr[pos].end>=p&&pos>=((size-1)/2))
				return pos;
			else
			{
				if(arr[2*pos+1].start<=p&&arr[2*pos+1].end>=p)
					return find(p,2*pos+1);
				else
					return find(p,2*pos+2);
			}
		}
		
	}
	public static void main(String[] Rohan)throws IOException
	{		
		int n=br.nextInt(),m=br.nextInt();
		pos=new node4pos[n];
		for(int i=0;i<n;i++)
		{
			pos[i]=new node4pos();
			pos[i].start=br.nextLong();pos[i].end=pos[i].start+(br.nextLong());pos[i].indx=i;
		}
		Arrays.sort(pos);
		Postree position=new Postree(n);
		position.build();
		//position.print();
		AVLTree avl=new AVLTree();
 
		for(int i=0;i<m;i++)
		{
			long p=br.nextLong(),w=br.nextLong();
			int check=position.find(p,0);
			if(check!=-1)
			{
				position.arr[check].count++;
				position.arr[check].end+=w;
				String[] checkAgain=(avl.get(avl.root,position.arr[check].start,position.arr[check].end)).split(" ");
				while(!checkAgain[0].equals("-1"))
				{
					
					//System.out.println("1");
					position.arr[check].end+=Long.parseLong(checkAgain[0]);
					position.arr[check].count+=Long.parseLong(checkAgain[1]);
					checkAgain=(avl.get(avl.root,position.arr[check].start,position.arr[check].end)).split(" ");
				}
				////// arr ko update krna matt bhooliyo
				position.update(check);
			}
			else
			{
				avl.root=avl.insert(avl.root,p,w);
			}
			
		}
		long[] dd=new long[n];long[] df=new long[n];
		for(int i=(position.size-1)/2;i<position.size&&position.arr[i].start!=Pinf;i++)
		{
			dd[position.arr[i].indx]=position.arr[i].count;
			df[position.arr[i].indx]=position.arr[i].end-position.arr[i].start;
		}
		for(int i=0;i<n;i++)
		{
			out.println(dd[i]+" "+df[i]);
		}
		out.close();
	
	}
}
class node4pos implements Comparable<node4pos>
{
	long start=0,end=0;int indx=-1;
	public int compareTo(node4pos n)
	{
		if(this.start-n.start!=0)
			return (int)(this.start-n.start);
		else
			return (int)(this.end-n.end);
	}
}
class nodeTreePos
{
	long count=0,start,end;int indx=-1;
	nodeTreePos(long s,long e)
	{
		start=s;end=e;
	}	
}
class Node
{
	long data,width;
	int depth=0,count=0;	
	Node left=null,right=null; 
	Node(long d,long w)
	{
		data=d;width=w;depth=1;count=1;
	}
}
 
 
 
 
class AVLTree
{
	Node root;
	String get(Node root,long s,long e)
	{
		if(root==null)
			return "-1 0";
		else if(s<=root.data&&e>=root.data)
		{
			String s1=String.valueOf(root.width)+" "+String.valueOf(root.count);
			this.root=delete(this.root,root.data);
			return s1;
		}
		else if(s>root.data)
			return get(root.right,s,e);							///////////////// else == wala case
		else
			return get(root.left,s,e);
 
	}
	int depth(Node N)
	{
		if(N==null)
			return 0;
		else
			return N.depth;
	}
	Node r_rotate(Node old)
	{
		Node new_=old.left;
		Node ORPHAN=new_.right;
		new_.right=old;
		old.left=ORPHAN;
		old.depth=(int)Math.max(depth(old.left), depth(old.right))+1;
		new_.depth=(int)Math.max(depth(new_.left), depth(new_.right))+1;
		return new_;
	}
 
 
	Node l_rotate(Node old)
	{
		Node new_=old.right;
		Node ORPHAN=new_.left;
		new_.left=old;
		old.right=ORPHAN;
		old.depth=(int)Math.max(depth(old.left), depth(old.right))+1;
		new_.depth=(int)Math.max(depth(new_.left), depth(new_.right))+1;
		return new_;
	}
 
 
 
	int Balance(Node n)
	{
		if(n==null)
			return 0;
		return depth(n.left)-depth(n.right);
	}
 
	Node insert(Node node,long data,long w)
	{
		if(node==null)
			return (new Node(data,w));
 		if(node.data==data)
 		{
 			node.count++;node.width+=w;
 			return node;
 		}
		else if(data<node.data)
			node.left=insert(node.left,data,w);
		else if(data>node.data)
			node.right=insert(node.right,data,w);
		else
			return node;
		node.depth=(int)Math.max(depth(node.left),depth(node.right))+1;
		int b_f=Balance(node);
		if (b_f<-1 && data>node.right.data)
			return l_rotate(node);
		else if (b_f>1 && data<node.left.data)
			return r_rotate(node);
		else if (b_f>1 && data>node.left.data)
		{
			node.left=l_rotate(node.left);
			return r_rotate(node);
		}
		else if (b_f<-1 && data<node.right.data)
		{
			node.right=r_rotate(node.right);
			return l_rotate(node);
		}
		else
			return node;
	}
 
	Node minValue(Node node)
	{
		Node curr=node;
		while (curr.left!=null)
		   curr=curr.left; 
		return curr;
	}
 
	Node delete(Node root,long data)
	{
		if(root==null)
			return root;
		if(data>root.data)
			root.right=delete(root.right,data);
		else if(data<root.data)
			root.left=delete(root.left,data);		
		else
		{ 
			if((root.left==null)||(root.right==null))
			{
				Node temp=null;
				if(temp==root.right)
					temp=root.left;
				else
					temp=root.right;
				if(temp!=null)
				{
					root=temp;
				}
				else
				{
					temp=root;
					root=null;
				}
					
			}
			else
			{
				Node temp=minValue(root.right);
				root.data=temp.data;root.width=temp.width;root.count=temp.count;
				root.right=delete(root.right,temp.data);
			}
		}
		if(root==null)
			return root;
		root.depth=(int)Math.max(depth(root.left),depth(root.right))+1;
		int b_f=Balance(root);
		if(b_f>1 && Balance(root.left)>=0)
			return r_rotate(root);
		else if(b_f<-1 && Balance(root.right) <= 0)
			return l_rotate(root);
		
		else if(b_f<-1 && Balance(root.right)>0)
		{
			root.right=r_rotate(root.right);
			return l_rotate(root);
		}
		else if(b_f>1 && Balance(root.left)<0)
		{
			root.left=l_rotate(root.left);
			return r_rotate(root);
		}
		else
			return root;
	}
}
