#include <bits/stdc++.h>
using namespace std;
const int N = 600010;
map<int, int> both[N];
int cost[N], rak[N], ord[N];
vector<pair<int, int> > c;
pair<int, int> qry[N];
set<int> st;
int single[N], single_both[N];
int ans[N];
struct tree {
  int lt, rt, mx;
} a[N << 2];
void init(int lt, int rt, int step) {
  a[step].lt = lt;
  a[step].rt = rt;
  a[step].mx = 0;
  if (lt == rt) return;
  int mid = (lt + rt) >> 1;
  init(lt, mid, step << 1);
  init(mid + 1, rt, step << 1 | 1);
}
void update(int pos, int step, int val) {
  if (a[step].lt == a[step].rt) {
    a[step].mx = val;
    return;
  }
  if (pos <= a[step << 1].rt)
    update(pos, step << 1, val);
  else
    update(pos, step << 1 | 1, val);
  a[step].mx = max(a[step << 1].mx, a[step << 1 | 1].mx);
}
int query(int lt, int rt, int step) {
  if (rt < a[step].lt || lt > a[step].rt || lt > rt) return 0;
  if (a[step].lt == lt && rt == a[step].rt) return a[step].mx;
  if (lt > a[step << 1].rt)
    return query(lt, rt, step << 1 | 1);
  else if (rt <= a[step << 1].rt)
    return query(lt, rt, step << 1);
  else
    return max(query(lt, a[step << 1].rt, step << 1),
               query(a[step << 1 | 1].lt, rt, step << 1 | 1));
}
bool cmp(int first, int second) { return cost[first] < cost[second]; }
int main() {
  int n, m, cos;
  scanf("%d%d", &n, &cos);
  for (int i = 1, first, second; i <= n; i++) {
    scanf("%d%d%d", &first, &second, &cost[i]);
    c.push_back(make_pair(first, i));
    c.push_back(make_pair(second, -i));
    rak[i] = i;
  }
  sort(rak + 1, rak + n + 1, cmp);
  for (int i = 1; i <= n; i++) ord[rak[i]] = i;
  sort(c.begin(), c.end());
  c.push_back(make_pair(2000000000, 0));
  scanf("%d", &m);
  for (int i = 1; i <= m; i++) {
    scanf("%d", &qry[i].first);
    qry[i].second = i;
    if (n == 0) printf("%d\n", qry[i].first);
  }
  if (n == 0) return 0;
  sort(qry + 1, qry + m + 1);
  init(1, n, 1);
  long long empty = 0, cover = 0;
  for (int i = 0, j = 1, last = 0; i < c.size(); ++i) {
    int seg = c[i].first - last;
    last = c[i].first;
    if (st.size() == 0) {
      empty += seg;
    } else if (st.size() == 1) {
      int first = *st.begin();
      if (cost[first] <= cos) {
        single[first] += seg;
        update(ord[first], 1, single[first]);
        int lt = 1, rt = n, mid, pos = 0;
        while (lt <= rt) {
          mid = (lt + rt) >> 1;
          if (cost[rak[mid]] + cost[first] <= cos)
            pos = mid, lt = mid + 1;
          else
            rt = mid - 1;
        }
        int len = single[first] + max(query(1, min(pos, ord[first] - 1), 1),
                                      query(ord[first] + 1, pos, 1));
        cover = max(cover, len + 0LL);
        cover = max(cover, single[first] + single_both[first] + 0LL);
      }
    } else if (st.size() == 2) {
      set<int>::iterator it = st.begin();
      int first = *it++;
      int second = *it;
      if (!both[first].count(second)) both[first][second] = 0;
      if (!both[second].count(first)) both[second][first] = 0;
      both[first][second] += seg;
      both[second][first] += seg;
      if (cost[first] + cost[second] <= cos) {
        single_both[first] =
            max(single_both[first], single[second] + both[first][second]);
        single_both[second] =
            max(single_both[second], single[first] + both[second][first]);
        cover = max(cover,
                    0LL + single[first] + single[second] + both[first][second]);
      }
    }
    if (c[i].second < 0)
      st.erase(-c[i].second);
    else
      st.insert(c[i].second);
    while (j <= m && qry[j].first <= empty + cover) {
      ans[qry[j].second] = last - (empty + cover - qry[j].first);
      j++;
    }
  }
  for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
  return 0;
}
