#include <bits/stdc++.h>

#define pb push_back
#define mp make_pair
#define fi first
#define se second

typedef long long LL;

using namespace std;

template <typename T> void inline chkMax(T &x, T y) { if (y > x) x = y; }
template <typename T> void inline chkMin(T &x, T y) { if (y < x) x = y; }


template <typename T> void inline read(T &x) {
    int f = 1; x = 0; char s = getchar();
    while (s < '0' || s > '9') { if (s == '-') f = -1; s = getchar(); }
    while (s <= '9' && s >= '0') x = x * 10 + (s ^ 48), s = getchar();
    x *= f;
}

const int N = 1e5 + 5, M = 1e6 + 5, INF = 2e9;

int n, m, q, a[N], s[N], c[N], x[N], Q[N], L, Lim;

int d[N], g[N];

LL ans[N];

int inline get(int i) {
	if (x[i] == 0) return 1000000;
	int t = (c[i] - d[i] - 1) / x[i] + 1;
	chkMax(Lim, t);
	return t;
}

int inline gx(int i) {
	return a[i] + (d[i] == 0 ? s[i] : 0);
}

bool inline check() {
	int s = 0;
	for (int i = 1; i <= Lim; i++) {
		s += g[i];
		if (s > m * i) return 0;	
	}
	return 1;
}

typedef pair<LL, int> PLI;

PLI inline operator + (PLI a, PLI b) {
	if (a.fi == b.fi) return a.se > b.se ? a : b;
	return a.fi < b.fi ? a : b;
}

#define ls (p << 1)
#define rs (p << 1 | 1)

struct S1{
	int n, tag[M << 2];
	PLI t[M << 2];
	
	void pushup(int p) {
		t[p] = t[ls] + t[rs];
	}
	
	void inline add(int p, int k) {
		tag[p] += k, t[p].fi += k;
	}
	
	void inline pushdown(int p) {
		if (tag[p]) {
			add(ls, tag[p]), add(rs, tag[p]);
			tag[p] = 0;
		}
	}
	void build(int p, int l, int r) {
		if (l == r) {
			t[p] = mp(1ll * m * r, r);
			return;	
		}
		int mid = (l + r) >> 1;
		build(ls, l, mid);
		build(rs, mid + 1, r);
		pushup(p);
	}
	void inline change(int p, int l, int r, int x, int y, int k) {
		if (x <= l && r <= y) {
			add(p, k);
			return ;
		}
		pushdown(p);
		int mid = (l + r) >> 1;
		if (x <= mid) change(ls, l, mid, x, y, k);
		if (mid < y) change(rs, mid + 1, r, x, y, k);
		pushup(p);
	}
	int inline get() {
		if (t[1].fi == 0) return t[1].se + 1;
		return 1;
	}
	void chg(int p) {
		if (p <= n) change(1, 1, n, p, n, -1);
	}
} t1;

PLI inline max(PLI a, PLI b) {
	return a > b ? a : b;
}



struct S2{
	int n;
	PLI t[M << 2];
	set<PLI> s[M];
	void pushup(int p) {
		t[p] = max(t[ls], t[rs]);		
	}
	void build(int p, int l, int r) {
		t[p] = mp(-INF, -INF);
		if (l == r) return;
		int mid = (l + r) >> 1;
		build(ls, l, mid);
		build(rs, mid + 1, r);		
	}
	void change(int p, int l, int r, int x, int k, int w, int o) {
		if (x > r) return;
		if (l == r) {
			if (o == 0) {
				s[r].erase(mp(w, k));
			} else {
				s[r].insert(mp(w, k));
			}
			if (s[r].size()) t[p] = *(--s[r].end());
			else t[p] = mp(-INF, -INF);
			return;
		}
		int mid = (l + r) >> 1;
		if (x <= mid) change(ls, l, mid, x, k, w, o);
		else change(rs, mid + 1, r, x, k, w, o);
		pushup(p);
	}
	PLI query(int p, int l, int r, int x, int y) {
		if (x <= l && r <= y) return t[p];
		int mid = (l + r) >> 1; PLI res = mp(-INF, -INF);
		if (x <= mid) res = max(res, query(ls, l, mid, x, y));
		if (mid < y) res = max(res, query(rs, mid + 1, r, x, y));
		return res;	
	}
	void inline add(int k) {
		int x = get(k), w = gx(k);
		change(1, 1, n, x, k, w, 1);
	}
	void inline del(int k) {
		int x = get(k), w = gx(k);
		change(1, 1, n, x, k, w, 0);
	}
	PLI inline query(int p) {
		return query(1, 1, n, p, n);	
	}
} t2;

int main() {
	read(n), read(m), read(q);
	for (int i = 1; i <= n; i++) read(a[i]), read(s[i]), read(c[i]), read(x[i]);
	for (int i = 1; i <= q; i++) {
		read(Q[i]);
		chkMax(L, Q[i]);
	}
	int S = 1e6;
	t1.n = S, t2.n = S;
	t1.build(1, 1, S);
	t2.build(1, 1, S); 
	for (int i = 1; i <= n; i++) t2.add(i);
	LL res = 0;
	for (int i = 1; i <= L; i++) {
		for (int j = 1; j <= m; j++) {
			int w = t1.get();
			if (w > L) break;
			PLI u = t2.query(w);
			if (u.fi < 0) break;
			res += u.fi;
			t1.chg(get(u.se));
			t2.del(u.se);
			d[u.se]++;
			if (d[u.se] < c[u.se]) {
				t2.add(u.se);
			}
		}
		ans[i] = res;
	}
	for (int i = 1; i <= q; i++) {
		printf("%lld\n", ans[Q[i]]);
	}
}