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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeMap;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author prakharjain
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        _609F solver = new _609F();
        solver.solve(1, in, out);
        out.close();
    }

    static class _609F {
        public static class IntervalTreeNonOverlap {

            int s;
            int e;

            public IntervalTreeNonOverlap(int s, int e) {
                this.s = s;
                this.e = e;
                root = new Node((s + e) / 2);
            }

            static class Interval {
                int s;
                int e;
                int i;
                Interval next;

                public Interval(int i, int s, int e) {
                    this.i = i;
                    this.s = s;
                    this.e = e;
                }
            }

            static class Node {
                int c;
                Interval interval;
                Node left;
                Node right;

                public Node(int c) {
                    this.c = c;
                }
            }

            Node root;

            void addInterval(Interval interval) {
                Node ci = root;

                int cs = s;
                int ce = e;

                while (true) {
                    if (ci.c >= interval.s && ci.c <= interval.e) {
                        ci.interval = interval;
                        break;
                    } else if (ci.c > interval.e) {
                        if (ci.left == null) {
                            ci.left = new Node((cs + ci.c - 1) / 2);
                        }
                        ce = ci.c - 1;
                        ci = ci.left;
                    } else {
                        if (ci.right == null) {
                            ci.right = new Node((ci.c + 1 + ce) / 2);
                        }
                        cs = ci.c + 1;
                        ci = ci.right;
                    }
                }
            }

            Interval searchInterval(int x) {
                Node ci = root;

                while (true) {
                    if (ci.interval != null && ci.interval.s <= x && ci.interval.e >= x) {
                        return ci.interval;
                    } else if (ci.interval == null && x == ci.c) {
                        return null;
                    } else if (x < ci.c) {
                        if (ci.left == null)
                            return null;
                        ci = ci.left;
                    } else if (x > ci.c) {
                        if (ci.right == null)
                            return null;
                        ci = ci.right;
                    }
                }
            }

            void deleteInterval(Interval interval) {
                Node ci = root;

                while (true) {
                    if (ci.c >= interval.s && ci.c <= interval.e) {
                        ci.interval = null;
                        break;
                    } else if (ci.c > interval.e) {
                        ci = ci.left;
                    } else {
                        ci = ci.right;
                    }
                }
            }
        }

        class frog {
            int x;
            int t;
            int i;

            public frog(int x, int t, int i) {
                this.x = x;
                this.t = t;
                this.i = i;
            }
        }

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int m = in.nextInt();

            int lie = -1;

            IntervalTreeNonOverlap it = new IntervalTreeNonOverlap(0, (int) 1e9);

            IntervalTreeNonOverlap.Interval head = null;
            IntervalTreeNonOverlap.Interval prev = null;
            int[] count = new int[n];
            long[] size = new long[n];

            frog[] frogs = new frog[n];

            for (int i = 0; i < n; i++) {
                frogs[i] = new frog(in.nextInt(), in.nextInt(), i);
            }

            Arrays.sort(frogs, (f1, f2) -> f1.x - f2.x);

            for (int i = 0; i < n; i++) {
                frog cf = frogs[i];
                int x = cf.x;
                int t = cf.t;
                int ci = cf.i;

                size[ci] += t;
                if (x + t <= lie)
                    continue;
                IntervalTreeNonOverlap.Interval cint =
                        new IntervalTreeNonOverlap.Interval(ci, Math.max(lie + 1, x), x + t);

                if (head == null) {
                    head = cint;
                    prev = cint;
                } else {
                    prev.next = cint;
                    prev = cint;
                }

                lie = x + t;
            }

            IntervalTreeNonOverlap.Interval cint = head;

            while (cint != null) {
                it.addInterval(cint);
                cint = cint.next;
            }

            TreeMap<Integer, List<Integer>> mm = new TreeMap<>();

            for (int i = 0; i < m; i++) {
                int p = in.nextInt();
                int b = in.nextInt();

                IntervalTreeNonOverlap.Interval sint = it.searchInterval(p);

                if (sint == null) {
                    if (!mm.containsKey(p)) {
                        mm.put(p, new ArrayList<>());
                    }
                    mm.get(p).add(b);
                } else {
                    int bl = sint.e;

                    count[sint.i]++;
                    size[sint.i] += b;

                    Integer nm = mm.ceilingKey(bl + 1);

                    long nbl = (long) bl + b;
                    while (nm != null && nm <= nbl) {
                        List<Integer> l = mm.get(nm);
                        for (int j = 0; j < l.size(); j++) {
                            count[sint.i]++;
                            size[sint.i] += l.get(j);
                            nbl += l.get(j);
                        }
                        mm.remove(nm);
                        nm = mm.ceilingKey(bl + 1);
                    }

                    nbl = Math.min(nbl, (int) 1e9);

                    IntervalTreeNonOverlap.Interval pn = sint;
                    for (IntervalTreeNonOverlap.Interval cn = sint.next; cn != null; cn = cn.next) {
                        if (cn.e <= nbl) {
                            pn.next = cn.next;
                            it.deleteInterval(cn);
                        } else if (cn.s <= nbl) {
                            it.deleteInterval(cn);
                            IntervalTreeNonOverlap.Interval nint = new IntervalTreeNonOverlap.Interval(cn.i, (int) nbl + 1, cn.e);
                            pn.next = nint;
                            nint.next = cn.next;
                            it.addInterval(nint);
                            pn = nint;
                        } else if (cn.s > nbl)
                            break;
                    }

                    it.deleteInterval(sint);
                    sint.e = (int) nbl;
                    it.addInterval(sint);
                }
            }

            StringBuilder ans = new StringBuilder();
            for (int i = 0; i < n; i++) {
                ans.append(count[i]);
                ans.append(" ");
                ans.append(size[i]);
                ans.append("\n");
            }

            out.println(ans.toString());
        }
    }


    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

