#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const long double PI = atan(1) * 4;
const long long M = 1000000007;
struct PT {
  double x, y;
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.y) {}
  PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
  PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
  PT operator*(double c) const { return PT(x * c, y * c); }
  PT operator/(double c) const { return PT(x / c, y / c); }
};
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
double cos_u2v(const PT &u, const PT &v) {
  return dot(u, v) / sqrt(dot(u, u) * dot(v, v));
}
double sin_u2v(const PT &u, const PT &v) {
  return cross(u, v) / sqrt(dot(u, u) * dot(v, v));
}
ostream &operator<<(ostream &os, const PT &p) {
  os << "(" << p.x << "," << p.y << ")";
}
double vector2angle(const PT &v) { return atan2(v.y, v.x); }
struct UnionFind {
  vector<long long> C;
  UnionFind(long long n) : C(n) {
    for (int i = 0; i < n; i++) C[i] = i;
  }
  long long find(long long x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
  void merge(long long x, long long y) { C[find(x)] = find(y); }
};
long long mod(long long x, long long m) { return ((x % m) + m) % m; }
long long gcd(long long a, long long b) {
  for (; b > 0; swap(a, b)) a %= b;
  return a;
}
long long extended_euclid(long long a, long long b, long long &x,
                          long long &y) {
  long long xx = y = 0;
  long long yy = x = 1;
  while (b) {
    long long q = a / b;
    long long t = b;
    b = a % b;
    a = t;
    t = xx;
    xx = x - q * xx;
    x = t;
    t = yy;
    yy = y - q * yy;
    y = t;
  }
  return a;
}
long long mod_inverse(long long a, long long n) {
  long long x, y;
  long long d = extended_euclid(a, n, x, y);
  if (d > 1) return -1;
  return mod(x, n);
}
struct LPSolver {
  int m, n;
  vector<long long> B, N;
  vector<vector<long double>> D;
  LPSolver(const vector<vector<long double>> &A, const vector<long double> &b,
           const vector<long double> &c)
      : m(b.size()),
        n(c.size()),
        N(n + 1),
        B(m),
        D(m + 2, vector<long double>(n + 2)) {
    for (int i = 0; i < m; i++)
      for (int j = 0; j < n; j++) D[i][j] = A[i][j];
    for (int i = 0; i < m; i++) {
      B[i] = n + i;
      D[i][n] = -1;
      D[i][n + 1] = b[i];
    }
    for (int j = 0; j < n; j++) {
      N[j] = j;
      D[m][j] = -c[j];
    }
    N[n] = -1;
    D[m + 1][n] = 1;
  }
  void Pivot(int r, int s) {
    for (int i = 0; i < m + 2; i++)
      if (i != r)
        for (int j = 0; j < n + 2; j++)
          if (j != s) D[i][j] -= D[r][j] * D[i][s] / D[r][s];
    for (int j = 0; j < n + 2; j++)
      if (j != s) D[r][j] /= D[r][s];
    for (int i = 0; i < m + 2; i++)
      if (i != r) D[i][s] /= -D[r][s];
    D[r][s] = 1.0 / D[r][s];
    swap(B[r], N[s]);
  }
  bool Simplex(int phase) {
    int x = phase == 1 ? m + 1 : m;
    while (true) {
      int s = -1;
      for (int j = 0; j <= n; j++) {
        if (phase == 2 && N[j] == -1) continue;
        if (s == -1 || D[x][j] < D[x][s] || D[x][j] == D[x][s] && N[j] < N[s])
          s = j;
      }
      if (D[x][s] > -EPS) return true;
      int r = -1;
      for (int i = 0; i < m; i++) {
        if (D[i][s] < EPS) continue;
        if (r == -1 || D[i][n + 1] / D[i][s] < D[r][n + 1] / D[r][s] ||
            (D[i][n + 1] / D[i][s]) == (D[r][n + 1] / D[r][s]) && B[i] < B[r])
          r = i;
      }
      if (r == -1) return false;
      Pivot(r, s);
    }
  }
  long double solve(vector<long double> &x) {
    int r = 0;
    for (int i = 1; i < m; i++)
      if (D[i][n + 1] < D[r][n + 1]) r = i;
    if (D[r][n + 1] < -EPS) {
      Pivot(r, n);
      if (!Simplex(1) || D[m + 1][n + 1] < -EPS)
        return -numeric_limits<long double>::infinity();
      for (int i = 0; i < m; i++)
        if (B[i] == -1) {
          int s = -1;
          for (int j = 0; j <= n; j++)
            if (s == -1 || D[i][j] < D[i][s] ||
                D[i][j] == D[i][s] && N[j] < N[s])
              s = j;
          Pivot(i, s);
        }
    }
    if (!Simplex(2)) return numeric_limits<long double>::infinity();
    x = vector<long double>(n);
    for (int i = 0; i < m; i++)
      if (B[i] < n) x[B[i]] = D[i][n + 1];
    return D[m][n + 1];
  }
};
void edgelist2adjlists(long long n, const vector<long long> &froms,
                       const vector<long long> &tos, vector<long long> &v2e0,
                       vector<long long> &e2n) {
  v2e0.resize(n);
  v2e0.assign(n, -1);
  long long en = froms.size();
  e2n.resize(en);
  for (int i = 0; i < en; i++) {
    long long f = froms[i];
    long long t = tos[i];
    e2n[i] = v2e0[f];
    v2e0[f] = i;
  }
}
struct FordFulk {
 private:
  const vector<long long> &v2e0;
  const vector<long long> &e2f;
  const vector<long long> &e2t;
  const vector<long long> &e2c;
  const vector<long long> &e2n;
  long long s, t;
  long long find_aug_path(const vector<long long> &v2e0,
                          const vector<long long> &e2f,
                          const vector<long long> &e2t,
                          const vector<long long> &e2c,
                          const vector<long long> &e2n, long long s,
                          long long t, vector<long long> &epath) {
    vector<long long> q2v;
    vector<long long> q2p;
    vector<long long> q2e;
    vector<long long> q2f;
    vector<bool> inq(v2e0.size(), false);
    q2v.push_back(s);
    q2p.push_back(-1);
    q2e.push_back(-1);
    q2f.push_back(INT_MAX);
    inq[s] = true;
    for (long long i = 0; i < q2v.size(); i++) {
      long long crt = q2v[i];
      long long f = q2f[i];
      for (long long j = v2e0[crt]; j != -1; j = e2n[j]) {
        long long to = e2t[j];
        long long rem = e2c[j];
        if (inq[to]) continue;
        if (rem <= 0) continue;
        q2v.push_back(to);
        q2p.push_back(i);
        q2e.push_back(j);
        q2f.push_back(min(f, rem));
        inq[to] = true;
      }
    }
    for (long long i = 0; i < q2v.size(); i++) {
      if (q2v[i] != t) continue;
      stack<long long> stk;
      for (long long j = i; j > 0; j = q2p[j]) {
        stk.push(q2e[j]);
      }
      while (!stk.empty()) {
        epath.push_back(stk.top());
        stk.pop();
      }
      return q2f[i];
    }
    return 0;
  }

 public:
  FordFulk(const vector<long long> &_v2e0, const vector<long long> &_e2f,
           const vector<long long> &_e2t, const vector<long long> &_e2c,
           const vector<long long> &_e2n, long long _s, long long _t)
      : s(_s), t(_t), v2e0(_v2e0), e2f(_e2f), e2t(_e2t), e2c(_e2c), e2n(_e2n) {}
  long long eval() {
    long long en = e2f.size();
    map<pair<long long, long long>, long long> rsd;
    for (long long i = 0; i < en; i++) {
      long long f = e2f[i];
      long long t = e2t[i];
      rsd[make_pair(f, t)] += e2c[i];
      rsd[make_pair(t, f)] += 0;
    }
    map<pair<long long, long long>, long long> nei;
    long long ren = 0;
    for (auto er : rsd) {
      nei[er.first] = ren++;
    }
    long long rvn = v2e0.size();
    vector<long long> rv2e0(rvn, -1);
    vector<long long> re2f(ren);
    vector<long long> re2t(ren);
    vector<long long> re2c(ren);
    vector<long long> re2n(ren);
    vector<long long> re2p(ren);
    long long rei = 0;
    for (auto er : rsd) {
      long long f = er.first.first;
      long long t = er.first.second;
      long long c = er.second;
      re2f[rei] = f;
      re2t[rei] = t;
      re2c[rei] = c;
      re2p[rei] = nei[make_pair(t, f)];
      re2n[rei] = rv2e0[f];
      rv2e0[f] = rei;
      ++rei;
    }
    long long sol = 0;
    vector<long long> epath;
    while (true) {
      epath.clear();
      long long res = find_aug_path(rv2e0, re2f, re2t, re2c, re2n, s, t, epath);
      if (res == 0) break;
      for (auto ei : epath) {
        re2c[ei] -= res;
        re2c[re2p[ei]] += res;
      }
      sol += res;
    }
    return sol;
  }
};
struct LazySegTree1D {
  vector<long long> v;
  vector<long long> p;
  vector<long long> l;
  long long LEFT;
  long long RGHT;
  LazySegTree1D(long long _l, long long _r, long long _v)
      : v(1), p(1), l(1), LEFT(_l), RGHT(_r) {
    v[0] = _v;
    p[0] = _v;
    l[0] = -1;
  }
  void _split(long long i) {
    assert(l[i] == -1);
    long long n = v.size();
    v.push_back(p[i]);
    v.push_back(p[i]);
    p.push_back(p[i]);
    p.push_back(p[i]);
    l.push_back(-1);
    l.push_back(-1);
    l[i] = n;
  }
  void _set(long long i, long long l0, long long r0, long long l1, long long r1,
            long long v1) {
    assert(l1 >= l0 && r1 <= r0);
    v[i] = min(v[i], v1);
    if (l0 == l1 && r0 == r1) {
      p[i] = min(p[i], v1);
      return;
    }
    long long m0 = (l0 + r0) / 2;
    if (l[i] == -1)
      _split(i);
    else {
      _set(l[i], l0, m0, l0, m0, p[i]);
      _set(l[i] + 1, m0 + 1, r0, m0 + 1, r0, p[i]);
    }
    if (l1 <= m0) _set(l[i], l0, m0, l1, min(r1, m0), v1);
    if (r1 > m0) _set(l[i] + 1, m0 + 1, r0, max(l1, m0 + 1), r1, v1);
  }
  long long _get(long long i, long long l0, long long r0, long long l1,
                 long long r1) {
    assert(l0 <= l1 && r1 <= r0);
    if (l0 == l1 && r1 == r0) return v[i];
    if (l[i] == -1) return v[i];
    long long m0 = (l0 + r0) / 2;
    _set(l[i], l0, m0, l0, m0, p[i]);
    _set(l[i] + 1, m0 + 1, r0, m0 + 1, r0, p[i]);
    bool lgood = (l1 <= m0);
    long long lv = (lgood) ? _get(l[i], l0, m0, l1, min(r1, m0)) : 0;
    bool rgood = (m0 + 1 <= r1);
    long long rv =
        (rgood) ? _get(l[i] + 1, m0 + 1, r0, max(m0 + 1, l1), r1) : 0;
    return (!lgood) ? rv : (!rgood) ? lv : min(lv, rv);
  }
  void set(long long l1, long long r1, long long v1) {
    _set(0, LEFT, RGHT, l1, r1, v1);
  }
  long long get(long long l1, long long r1) {
    return _get(0, LEFT, RGHT, l1, r1);
  }
};
void asd() {
  LazySegTree1D tree(0, 44444, 2222);
  cout << tree.v.size() << endl;
}
void readll(long long &x) {
  int r;
  scanf("%d", &r);
  x = r;
}
int main() {
  long long n, m;
  readll(n);
  readll(m);
  vector<long long> x(n);
  vector<long long> t(n);
  vector<long long> kil(n);
  vector<pair<long long, long long>> xi(n);
  long long maxreach = 0;
  long long fmax = 0;
  long long mmax = 0;
  for (long long i = 0; i < n; i++) {
    readll(x[i]);
    readll(t[i]);
    xi[i] = make_pair(x[i], i);
    fmax = max(fmax, x[i] + t[i]);
  }
  sort(xi.begin(), xi.end());
  vector<long long> p(m);
  vector<long long> b(m);
  for (long long i = 0; i < m; i++) {
    readll(p[i]);
    readll(b[i]);
    mmax = max(mmax, p[i]);
    fmax += b[i];
  }
  LazySegTree1D tree(0, max(fmax, mmax), n);
  for (long long i = 0; i < n; i++) {
    long long fgi = xi[i].second;
    long long x0 = x[fgi];
    long long x1 = x[fgi] + t[fgi];
    tree.set(x0, x1, i);
  }
  map<long long, long long> p2t;
  map<long long, long long> p2c;
  for (long long i = 0; i < m; i++) {
    p2t[p[i]] += b[i];
    p2c[p[i]]++;
    auto itt = p2t.find(p[i]);
    auto itc = p2c.find(p[i]);
    while (true) {
      if (itt == p2t.end()) {
        assert(itc == p2c.end());
        break;
      }
      long long pos = itt->first;
      long long j = tree.get(pos, pos);
      if (j == n) break;
      long long fgi = xi[j].second;
      kil[fgi] += itc->second;
      t[fgi] += itt->second;
      tree.set(x[fgi], x[fgi] + t[fgi], j);
      itt = p2t.erase(itt);
      itc = p2c.erase(itc);
    }
  }
  for (long long i = 0; i < n; i++) {
    int ti = t[i];
    int ki = kil[i];
    printf("%d %d\n", ki, ti);
  }
  return 0;
}
