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

/**
 * Competitive-Programming-and-Contests-VP-Solution a collection of
 * code with an engineering approach to solve the problem.
 * https://github.com/vincenzopalazzo/Competitive-Programming-and-Contests-VP-Solution
 *
 * Copyright (C) 2020-2021  Vincenzo Palazzo vincenzopalazzodev@gmail.com
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <set>
#include <algorithm>

using namespace std;

typedef std::make_signed<std::size_t>::type ssize_t;

template<typename T>
struct Frog {
    T length_tongue;
    std::size_t position;
    std::size_t mosquito_eaten = 0;
    std::size_t input_pos;

    Frog(std::size_t position, T lengthTongue, std::size_t input_pos):
            position(position), length_tongue(lengthTongue), input_pos(input_pos) {
    }

    bool operator <(Frog const &a)const{
        return position < a.position;
    }
};

template<typename T>
struct Mosquito {
    std::size_t position;
    T dimension;

    Mosquito(std::size_t position, T dimension){
        this->dimension = dimension;
        this->position = position;
    }
};

namespace cpstl {
    template <class T>
    class SegmentTree {
    private:
        std::vector<Frog<T>> origin;
        std::vector<T> structure;

        /**
         * This function is used build the segment tree with a binary heap
         * implementation, and it use the origin array stored in the class.
         * @tparam T is the type of structure, usually it is a int or another numeric
         * type
         * @param left_index the left index of the range
         * @param right_index the right index of the range
         */
        void build_structure(int left_index, int right_index) {
            build_structure_procedure(1, left_index, right_index - 1);
        }
        /**
         * This is the sub procedure that help the build_structure procedure to make
         * the logic inside the segment tree
         * @tparam T is the type of structure, usually it is a int or another numeric
         * type
         * @param start_index
         * @param left_index
         * @param right_index
         */
        void build_structure_procedure(std::size_t start_index, std::size_t left_index,
                                       std::size_t right_index) {
            if (left_index == right_index) {
                // Leaf node will have a single element
                structure[start_index] = (origin[left_index].position + origin[left_index].length_tongue);
                return;
            }
            auto middle_point = (left_index + right_index) / 2;
            auto left_child = left_child_index(start_index);
            auto right_child = right_child_index(start_index);
            build_structure_procedure(left_child, left_index, middle_point);
            build_structure_procedure(right_child, middle_point + 1, right_index);
            // Internal node will have the sum of both of its children
            auto segment_left = structure[left_child];
            auto segment_right = structure[right_child];
            structure[start_index] = std::max(segment_left, segment_right);
        }

        T range_query_subroutine(std::size_t start_index, std::size_t left_index_now,
                                 std::size_t right_index_now, std::size_t query_left,
                                 std::size_t query_right) {
            if (query_left > right_index_now || query_right < left_index_now)
                return -1;  // outside the range
            if (left_index_now >= query_left && right_index_now <= query_right)
                return structure[start_index];  // range represented by a node is
            // completely inside the given range
            // range represented by a node is partially inside and partially outside the
            // given range
            auto middle_point = (left_index_now + right_index_now) / 2;
            auto left_child = left_child_index(start_index);
            auto right_child = right_child_index(start_index);
            auto left_segment = range_query_subroutine(
                    left_child, left_index_now, middle_point, query_left, query_right);
            auto right_segment =
                    range_query_subroutine(right_child, middle_point + 1, right_index_now,
                                           query_left, query_right);
            if (left_segment == -1) return right_segment;
            if (right_segment == -1) return left_segment;
            return std::max(left_segment, right_segment);
        }

        void update_subroutine(std::size_t start_index, std::size_t left_index, std::size_t right_index,
                               std::size_t pos, T new_value) {
            if (left_index == right_index) {
                structure[start_index] += new_value;
            } else {
                auto middle_point = (left_index + right_index) / 2;
                auto left_child = left_child_index(start_index);
                auto right_child = right_child_index(start_index);
                if (pos <= middle_point) {
                    update_subroutine(left_child, left_index, middle_point, pos, new_value);
                } else {
                    update_subroutine(right_child, middle_point + 1, right_index, pos,
                                      new_value);
                }
                auto segment_left = structure[left_child];
                auto segment_right = structure[right_child];
                structure[start_index] = std::max(segment_left, segment_right);
            }
        }

        inline std::size_t left_child_index(std::size_t const index) {
            return index * 2;
        }

        inline std::size_t right_child_index(std::size_t const index) {
            return (index * 2) + 1;
        }

    public:
        SegmentTree(std::vector<Frog<T>> &origin) : origin(origin) {
            auto size = origin.size();
            structure = std::vector<T>(size * 4);
            origin = origin;
            build_structure(0, size);
        }

        virtual ~SegmentTree() { structure.clear(); }

        T range_query(std::size_t start_index, std::size_t end_index) {
            return range_query_subroutine(1, 0, origin.size() - 1, start_index,
                                          end_index);
        }

        /**
         * This is the sub procedure that help the build_structure procedure to make
         * the logic inside the segment tree
         * @param at: it is the position in the original array, the function change
         * the value also in the original array
         * @param new_value the value that we want override in position at.
         */
        void update(std::size_t const at, T value) {
            update_subroutine(1, 0, origin.size() - 1, at, value);
        }
    };
};  // namespace cpstl

// get better name
template<typename T>
ssize_t solve(cpstl::SegmentTree<T> &segment_tree, std::vector<T> &index_frogs, std::size_t position_mosquito) {
    std::size_t start_range = 0;
    auto it_end_range = std::upper_bound(index_frogs.begin(), index_frogs.end(), position_mosquito);
    auto end_range = std::distance(index_frogs.begin(), it_end_range) - 1;
    auto pos_frog = segment_tree.range_query(start_range, end_range);
    if (pos_frog < position_mosquito) {
        return -1; // no mosquito to eat
    }
    std::size_t middle_point;
    while (start_range < end_range) {
        middle_point = (start_range + end_range) / 2;
        pos_frog = segment_tree.range_query(0, middle_point);
        if (start_range < pos_frog)
            start_range = middle_point + 1;
        else
            end_range = middle_point - 1;
    }
    return start_range;
}

template<typename T, typename R>
void mosquitoes_eaten(std::vector<Frog<T>> &frogs, std::vector<Mosquito<T>> &mosquitoes) {
    std::sort(frogs.begin(), frogs.end());
    // We need to do remapping and store a vector if position
    // because the upperbound is a little bit complex with the personal structure
    // https://stackoverflow.com/questions/44245803/using-lower-bound-or-upper-bound-on-structure-in-c
    std::vector<T> index_frogs;
    index_frogs.reserve(frogs.size());
    for (auto const &frog : frogs)
        index_frogs.emplace_back(frog.position);
    auto segment_tree = cpstl::SegmentTree<T>(frogs);
    std::multiset<std::pair<T, R>> solutions;
    for (auto const &mosquito : mosquitoes) {
        auto frog_pos = solve(segment_tree, index_frogs, mosquito.position);
        if (frog_pos <= -1) {
            solutions.insert(std::pair<T, R>(mosquito.position, mosquito.dimension));
        } else {
            auto frog = &frogs.at(frog_pos);
            frog->mosquito_eaten++;
            frog->length_tongue += mosquito.dimension;
            segment_tree.update(frog_pos, mosquito.dimension);
            auto new_length_tongue = frog->length_tongue + frog->position;
            while (!solutions.empty()) {
                auto new_mosquito = solutions.lower_bound(std::pair<T, R>(frog->position, 0));
                if (new_mosquito == solutions.end() || new_mosquito->first > new_length_tongue) {
                    break;
                }
                new_length_tongue += new_mosquito->second;
                frog->mosquito_eaten++;
                frog->length_tongue += new_mosquito->second;
                segment_tree.update(frog_pos, new_mosquito->second);
                solutions.erase(new_mosquito);
            }
        }
    }
    std::sort(frogs.begin(), frogs.end(), [](auto frog_a, auto frog_b){
        return frog_a.input_pos < frog_b.input_pos;
    });
}


int main() {
    int F, M;
    scanf("%d", &F);
    scanf("%d", &M);
    std::vector<Frog<long long>> frogs;
    frogs.reserve(F);
    for (int i = 0; i < F; i++) {
        std::size_t pos;
        long long len;
        scanf("%ld", &pos);
        scanf("%lld", &len);
        frogs.emplace_back(pos, len, i);
    }

    std::vector<Mosquito<long long>> mosquitoes;
    mosquitoes.reserve(M);
    for (int i = 0; i < M; i++) {
        std::size_t pos;
        long long dim;
        scanf("%ld", &pos);
        scanf("%lld", &dim);
        mosquitoes.emplace_back(pos, dim);
    }

    mosquitoes_eaten<long long, long long>(frogs, mosquitoes);
    for (auto frog : frogs)
        printf("%lu %lld\n", frog.mosquito_eaten, frog.length_tongue);

    return EXIT_SUCCESS;
}
