Motorist Kojiro spent 10 years saving up for his favorite car brand, Furrari. Finally Kojiro's dream came true! Kojiro now wants to get to his girlfriend Johanna to show off his car to her.

Kojiro wants to get to his girlfriend, so he will go to her along a coordinate line. For simplicity, we can assume that Kojiro is at the point f of a coordinate line, and Johanna is at point e. Some points of the coordinate line have gas stations. Every gas station fills with only one type of fuel: Regular-92, Premium-95 or Super-98. Thus, each gas station is characterized by a pair of integers ti and xi — the number of the gas type and its position.

One liter of fuel is enough to drive for exactly 1 km (this value does not depend on the type of fuel). Fuels of three types differ only in quality, according to the research, that affects the lifetime of the vehicle motor. A Furrari tank holds exactly s liters of fuel (regardless of the type of fuel). At the moment of departure from point f Kojiro's tank is completely filled with fuel Super-98. At each gas station Kojiro can fill the tank with any amount of fuel, but of course, at no point in time, the amount of fuel in the tank can be more than s liters. Note that the tank can simultaneously have different types of fuel. The car can moves both left and right.

To extend the lifetime of the engine Kojiro seeks primarily to minimize the amount of fuel of type Regular-92. If there are several strategies to go from f to e, using the minimum amount of fuel of type Regular-92, it is necessary to travel so as to minimize the amount of used fuel of type Premium-95.

Write a program that can for the m possible positions of the start fi minimize firstly, the amount of used fuel of type Regular-92 and secondly, the amount of used fuel of type Premium-95.

Input

The first line of the input contains four positive integers e, s, n, m (1 ≤ e, s ≤ 109, 1 ≤ n, m ≤ 2·105) — the coordinate of the point where Johanna is, the capacity of a Furrari tank, the number of gas stations and the number of starting points. 

Next n lines contain two integers each ti, xi (1 ≤ ti ≤ 3, - 109 ≤ xi ≤ 109), representing the type of the i-th gas station (1 represents Regular-92, 2 — Premium-95 and 3 — Super-98) and the position on a coordinate line of the i-th gas station. Gas stations don't necessarily follow in order from left to right.

The last line contains m integers fi ( - 109 ≤ fi < e). Start positions don't necessarily follow in order from left to right.

No point of the coordinate line contains more than one gas station. It is possible that some of points fi or point e coincide with a gas station.

Output

Print exactly m lines. The i-th of them should contain two integers — the minimum amount of gas of type Regular-92 and type Premium-95, if Kojiro starts at point fi. First you need to minimize the first value. If there are multiple ways to do it, you need to also minimize the second value.

If there is no way to get to Johanna from point fi, the i-th line should look like that "-1 -1" (two numbers minus one without the quotes).

Examples

Input

8 4 1 1
2 4
0


Output

0 4


Input

9 3 2 3
2 3
1 6
-1 0 1


Output

-1 -1
3 3
3 2


Input

20 9 2 4
1 5
2 10
-1 0 1 2


Output

-1 -1
-1 -1
-1 -1
-1 -1
#include <bits/stdc++.h>
using namespace std;
int main() {
  int f, e, s, n, m, t, x, l;
  vector<pair<int, int>> g;
  scanf("%d", &(e));
  scanf("%d", &(s));
  scanf("%d", &(n));
  scanf("%d", &(m));
  for (__typeof(n) _i = 0; _i < (n); ++_i) {
    scanf("%d", &(t));
    scanf("%d", &(x));
    g.push_back({x, t});
  }
  sort(g.begin(), g.end());
  g.push_back({1000000007, 0});
  int gas[4] = {2 * 1000000007, 0, 0, 0};
  vector<tuple<int, int, int>> xlt;
  x = -1000000007;
  for (auto p : g) {
    int xn = p.first;
    t = p.second;
    for (int t1 = 3, dx = 0; t1 >= 0; t1--) {
      l = ((gas[t1]) > (xn - x) ? (xn - x) : (gas[t1]));
      gas[t1] -= l;
      if (l > dx) {
        xlt.push_back(make_tuple(x + dx, l - dx, t1));
        dx = l;
      }
    }
    x = xn;
    gas[t] = s;
  }
  xlt.push_back(make_tuple(1000000007, 0, 0));
  vector<vector<int>> need(4, vector<int>(1));
  for (auto t : xlt)
    for (__typeof(4) i = 0; i < 4; ++i)
      need[i].push_back(need[i].back() + (get<2>(t) == i ? get<1>(t) : 0));
  int end =
      lower_bound(xlt.begin(), xlt.end(), make_tuple(e, 0, 0)) - xlt.begin();
  int endtype = get<2>(xlt[end - 1]);
  need[endtype][end] -= get<0>(xlt[end]) - e;
  for (__typeof(m) _i = 0; _i < (m); ++_i) {
    scanf("%d", &(f));
    if (e - f <= s) {
      cout << "0 0" << endl;
      continue;
    }
    int start =
        lower_bound(xlt.begin(), xlt.end(), make_tuple(f + s + 1, 0, 0)) -
        xlt.begin() - 1;
    int starttype = get<2>(xlt[start]);
    if (starttype == 0 || endtype == 0 || need[0][end] != need[0][start]) {
      cout << "-1 -1" << endl;
      continue;
    }
    int need1 = need[1][end] - need[1][start];
    int need2 = need[2][end] - need[2][start];
    if (starttype == 1) need1 -= f + s - get<0>(xlt[start]);
    if (starttype == 2) need2 -= f + s - get<0>(xlt[start]);
    cout << need1 << " " << need2 << endl;
  }
  return 0;
}
