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 <bits/stdc++.h>
using namespace std;
template <class T>
bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
  for (auto &v : vec) is >> v;
  return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
  for (int i = 0; i < vec.size(); i++) {
    os << vec[i];
    if (i + 1 != vec.size()) os << " ";
  }
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &st) {
  for (auto itr = st.begin(); itr != st.end(); ++itr) {
    os << *itr;
    auto titr = itr;
    if (++titr != st.end()) os << " ";
  }
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &st) {
  for (auto itr = st.begin(); itr != st.end(); ++itr) {
    os << *itr;
    auto titr = itr;
    if (++titr != st.end()) os << " ";
  }
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &st) {
  for (auto itr = st.begin(); itr != st.end(); ++itr) {
    os << *itr;
    auto titr = itr;
    if (++titr != st.end()) os << " ";
  }
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &st) {
  for (auto itr = st.begin(); itr != st.end(); ++itr) {
    os << *itr;
    auto titr = itr;
    if (++titr != st.end()) os << " ";
  }
  return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
  os << p.first << " " << p.second;
  return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const map<T1, T2> &mp) {
  for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
    os << itr->first << ":" << itr->second;
    auto titr = itr;
    if (++titr != mp.end()) os << " ";
  }
  return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const unordered_map<T1, T2> &mp) {
  for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
    os << itr->first << ":" << itr->second;
    auto titr = itr;
    if (++titr != mp.end()) os << " ";
  }
  return os;
}
using ll = long long int;
using P = pair<int, int>;
const int inf = 1e9;
const ll linf = 1LL << 50;
const double EPS = 1e-10;
const int mod = 1000000007;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
struct fast_io {
  fast_io() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout << fixed << setprecision(20);
  }
} fast_io_;
template <typename T, typename E>
struct LazySegmentTree_ {
  function<T(T, T)> f;
  function<E(E, E)> h;
  function<T(T, E, int)> p;
  int n;
  T def;
  E l_def;
  vector<T> vec;
  vector<E> lazy;
  LazySegmentTree_() {}
  LazySegmentTree_(int n_, function<T(T, T)> f, T def, function<E(E, E)> h,
                   E l_def, function<T(T, E, int)> p, vector<T> v = vector<T>())
      : f(f), def(def), h(h), l_def(l_def), p(p) {
    n = 1;
    while (n < n_) {
      n *= 2;
    }
    vec = vector<T>(2 * n - 1, def);
    lazy = vector<E>(2 * n - 1, l_def);
    for (int i = 0; i < v.size(); i++) {
      vec[i + n - 1] = v[i];
    }
    for (int i = n - 2; i >= 0; i--) {
      vec[i] = f(vec[2 * i + 1], vec[2 * i + 2]);
    }
  }
  void eval(int k, int len) {
    if (lazy[k] != l_def) {
      if (k < n - 1) {
        lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
        lazy[2 * k + 2] = h(lazy[2 * k + 2], lazy[k]);
      }
      vec[k] = p(vec[k], lazy[k], len);
      lazy[k] = l_def;
    }
  }
  T update(int a, int b, const E &val, int k, int l, int r) {
    eval(k, r - l);
    if (r <= a || b <= l) {
      return vec[k];
    } else if (a <= l && r <= b) {
      lazy[k] = h(lazy[k], val);
      eval(k, r - l);
      return vec[k];
    } else {
      return vec[k] = f(update(a, b, val, 2 * k + 1, l, (l + r) / 2),
                        update(a, b, val, 2 * k + 2, (l + r) / 2, r));
    }
  }
  T update(int a, int b, E val) { return update(a, b, val, 0, 0, n); }
  T query(int a, int b, int k, int l, int r) {
    eval(k, r - l);
    if (r <= a || b <= l) return def;
    if (a <= l && r <= b) return vec[k];
    T ld = query(a, b, 2 * k + 1, l, (l + r) / 2);
    T rd = query(a, b, 2 * k + 2, (l + r) / 2, r);
    return f(ld, rd);
  }
  T query(int a, int b) { return query(a, b, 0, 0, n); }
};
template <typename T, typename E>
using LazySegmentTree = struct LazySegmentTree_<T, E>;
using LazySegmentTreeI = LazySegmentTree<int, int>;
using LazySegmentTreeL = LazySegmentTree<long long, long long>;
int main(int argc, char const *argv[]) {
  int n, m;
  cin >> n >> m;
  vector<ll> x(n), t(n);
  for (int i = (0); i < (n); ++i) cin >> x[i] >> t[i];
  vector<ll> p(m), b(m);
  for (int i = (0); i < (m); ++i) cin >> p[i] >> b[i];
  vector<pair<ll, int>> pt(m);
  for (int i = (0); i < (m); ++i) pt[i] = make_pair(p[i], i);
  sort((pt).begin(), (pt).end());
  map<ll, int> mpe;
  for (int i = (0); i < (n); ++i) mpe[x[i]] = i;
  vector<ll> pt2(m);
  for (int i = (0); i < (m); ++i) pt2[i] = pt[i].first;
  map<pair<ll, int>, int> mp;
  for (int i = (0); i < (m); ++i) mp[pt[i]] = i;
  LazySegmentTreeL seg1 = LazySegmentTreeL(
      m, [](ll a, ll b) { return min(a, b); }, linf,
      [](ll a, ll b) { return min(a, b); }, linf + 1,
      [](ll a, ll b, int c) { return min(a, b); }, vector<ll>(m, linf));
  LazySegmentTreeL seg2 = LazySegmentTreeL(
      m, [](ll a, ll b) { return a + b; }, 0, [](ll a, ll b) { return b; },
      linf, [](ll a, ll b, int c) { return b * c; }, vector<ll>(m, 0));
  LazySegmentTreeL seg3 = LazySegmentTreeL(
      m, [](ll a, ll b) { return a + b; }, 0, [](ll a, ll b) { return b; },
      linf, [](ll a, ll b, int c) { return b * c; }, vector<ll>(m, 0));
  for (int i = (0); i < (n); ++i) {
    int l = lower_bound((pt2).begin(), (pt2).end(), x[i]) - pt2.begin();
    int r = upper_bound((pt2).begin(), (pt2).end(), x[i] + t[i]) - pt2.begin();
    seg1.update(l, r, x[i]);
  }
  vector<ll> res(n, 0);
  for (int i = (0); i < (m); ++i) {
    int idx = mp[make_pair(p[i], i)];
    ll f = seg1.query(idx, idx + 1);
    if (f == linf) {
      seg2.update(idx, idx + 1, b[i]);
      seg3.update(idx, idx + 1, 1LL);
    } else {
      f = mpe[f];
      res[f] += 1;
      t[f] += b[i];
      while (true) {
        int l = lower_bound((pt2).begin(), (pt2).end(), x[f]) - pt2.begin();
        int r =
            upper_bound((pt2).begin(), (pt2).end(), x[f] + t[f]) - pt2.begin();
        ll s = seg3.query(l, r);
        if (s == 0) break;
        res[f] += s;
        seg3.update(l, r, 0);
        t[f] += seg2.query(l, r);
        seg2.update(l, r, 0);
      }
      int l = lower_bound((pt2).begin(), (pt2).end(), x[f]) - pt2.begin();
      int r =
          upper_bound((pt2).begin(), (pt2).end(), x[f] + t[f]) - pt2.begin();
      seg1.update(l, r, x[f]);
    }
  }
  for (int i = (0); i < (n); ++i) {
    cout << res[i] << " " << t[i] << endl;
  }
  return 0;
}
