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

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>

using namespace std;

// https://codeforces.com/contest/609/problem/F?locale=en

/*
    frogs_and_mosquitoes (time complexity: O(n log n), space complexity: O(n))
        Uses a BST a sweeping line algorithm approach and a pre-processing phase
        to eliminate all frog sovrapposition. Then, the fall of mosquitoes is simulated.
        The closest frog collects all possible mosquitoes, and after its tongue being
        expanded, the invariant of the frogs being all non-overlapping is restored in O(n log n).
        The complexity described is achieved thanks to the fact that as frogs get bigger
        so does their probability of completely removing another frog from the space.
        For each non-overlapping restoring, the following global cases can happen:
            - no frogs are modified       (O(  log n) complexity)
            - k frogs have to be modified (O(k log n) complexity)
        In the last case, it is easy to see that (using the assumption that all frogs are
        non-overlapping) all frogs except one are removed from the board.
        This ensures that the overall amortized complexity remains O(n log n).
*/

class frog {
    int64_t _a;
    int64_t _b;
    int64_t _tongue;
    int64_t _mosquitoes_eaten;
public:
    frog(int64_t a, int64_t tongue)
        : _a(a), _b(a + tongue), _tongue(tongue), _mosquitoes_eaten(0) {}
    frog() {}
    int64_t a()                { return _a;                }
    int64_t b()                { return _b;                }
    int64_t tongue()           { return _tongue;           }
    int64_t mosquitoes_eaten() { return _mosquitoes_eaten; }
    void eat(int64_t v) { _tongue += v; _b += v; _mosquitoes_eaten++; }
};

void frogs_and_mosquitoes(vector<pair<int64_t, int64_t>> const& input_frogs, vector<pair<int64_t, int64_t>> const& mosquitoes) {
    vector<frog> frogs;
    frogs.reserve(input_frogs.size());

    // Initialize global frog data
    for(auto const& frog : input_frogs)
        frogs.emplace_back(frog.first, frog.second);

    map<int64_t, frog*> pond;

    // Utility function that realigns the current frog so that there are no
    // one-tier overlaps after it, then advances the iterator to the next useful frog
    auto adjust_overlapping_frog = [&](map<int64_t, frog*>::iterator it) {
        if(it == pond.end())
            return;
        auto rightmost_tongue = it->second->b();
        // Start checking the next frog, and continue while there is any overlap
        for(++it; it != pond.end() && it->first <= rightmost_tongue;) {
            auto frog = it->second;
            // The frog is going to be repositioned or removed either way
            it = pond.erase(it);
            // If the frog is completely contained in the ones being considered,
            if(frog->b() > rightmost_tongue) {
                // There is a partial overlap: reposition it at the end of the last tongue checked.
                // The frog by itself only keeps the b() right endpoint, which must not move for
                // this operation. The one kept in the map is the true left starting position.
                rightmost_tongue = frog->b();
                pond.insert({rightmost_tongue + 1, frog});
                return;
            }
        }
    };

    // Insert the frogs inside the pond while removing all any-tier overlapping
    vector<frog*> sorted_frogs(frogs.size());
    transform(frogs.begin(), frogs.end(), sorted_frogs.begin(), [](auto& x) { return &x; });
    sort(sorted_frogs.begin(), sorted_frogs.end(), [](auto& x, auto& y) { return x->a() < y->a(); });
    int64_t rightmost_tongue = -1;
    for(auto& frog : sorted_frogs)
        // Insert this frog only if it's not contained in the previous one
        if(frog->b() > rightmost_tongue) {
            // If the frog is disjoint from the end of the previous one, use its position;
            // otherwise, adjust it to be immediately next to the end of the previous to maintain disjointness
            pond.insert({max(rightmost_tongue + 1, frog->a()), frog});
            rightmost_tongue = frog->b();
        }

    multimap<int64_t, int64_t> landed_mosquitoes;
    for(auto const& m : mosquitoes) {
        // Find the current candidate frog (the earliest frog before the placed mosquito)
        // This requires the frogs to be non-overlapping to work
        auto frog_it     = --pond.upper_bound(get<0>(m));
        auto mosquito_it = landed_mosquitoes.insert(m);
        // Increase the current candidate frog as much as possible
        while(frog_it != pond.end() // This can happen if the mosquito is before all frogs
           && mosquito_it != landed_mosquitoes.end()
           && frog_it->first <= mosquito_it->first && mosquito_it->first <= frog_it->second->b()) {
            frog_it->second->eat(mosquito_it->second);
            mosquito_it = landed_mosquitoes.erase(mosquito_it);
        }
        adjust_overlapping_frog(frog_it);
    }

    for(size_t i = 0; i < frogs.size(); i++)
        cout << frogs[i].mosquitoes_eaten() << " " << frogs[i].tongue() << endl;
}

template<typename L, typename R> vector<pair<L, R>> read_sequence2(size_t n) {
    vector<pair<L, R>> input;
    input.reserve(n);
    for(size_t i = 0; i < n; i++) {
        L a; R b;
        cin >> a >> b;
        input.emplace_back(a, b);
    }
    return input;
}

int main() {
    size_t N, M;
    cin >> N >> M;

    auto frogs      = read_sequence2<int64_t, int64_t>(N);
    auto mosquitoes = read_sequence2<int64_t, int64_t>(M);

    frogs_and_mosquitoes(frogs, mosquitoes);
}
