#include<bits/stdc++.h>
using i64 = long long;
const int mod = 1e9 + 7;
struct Matrix {
	int n = 4;
	std::vector<std::vector<int> > M;
	Matrix() {}
	void init(int n = 4) {
		this -> n = n;
		M.assign(n + 1, std::vector<int>(n + 1, 0));
	}
	void norm() {
		init();
		for (int i = 1; i <= n; i ++) {
			M[i][i] = 1;
		}
	}
	void Form(int v) {
		init();
		norm();
		M[1][2] = v;
		M[1][3] = M[1][4] = 1ll * v * v % mod;
		M[2][3] = M[2][4] = 2 * v % mod;
		M[3][4] = 1;
	}
	Matrix friend operator * (const Matrix &a, const Matrix &b) {
		Matrix ans;
		int n = a.n;
		ans.init(n);
		for (int i = 1; i <= n; i ++) {
			for (int j = 1; j <= n; j ++) {
				for (int k = 1; k <= n; k ++) {
					ans.M[i][j] = (1ll * ans.M[i][j] + 1ll * a.M[i][k] * b.M[k][j] % mod) % mod;
				}
			}
		}
		return ans;
	}
	Matrix friend operator + (const Matrix &a, const Matrix &b) {
		Matrix ans;
		int n = a.n;
		ans.init(n);
		for (int i = 1; i <= n; i ++) {
			for (int j = 1; j <= n; j ++) {
				ans.M[i][j] = (a.M[i][j] + b.M[i][j]) % mod;
			}
		}
		return ans;
	}
};

struct SegmentTree {
    int n;
    struct node {
        int l, r;
        Matrix add;
        Matrix val;
    };
    std::vector<node> t;
    std::vector<int> a;
    SegmentTree() {}
    void init(int n, std::vector<int> v) {
    	Matrix st;
    	st.init();
        this -> n = n;
        t.assign(4 * n + 1, (node) {0, 0, st, st});
        a.assign(v.begin(), v.end());
        build(1, 1, n);
    }
    void pushup(int u) {
        t[u].val = t[u << 1].val + t[u << 1 | 1].val;
    }
    void pushdown(int u) {
        t[u << 1].val = t[u << 1].val * t[u].add;
        t[u << 1 | 1].val = t[u << 1 | 1].val * t[u].add;
        t[u << 1].add = t[u << 1].add * t[u].add;
 		t[u << 1 | 1].add = t[u << 1 | 1].add * t[u].add;
 		t[u].add.norm();
    }
    void build(int u, int l, int r) {
        t[u].l = l;
        t[u].r = r;
        t[u].add.norm();
        if (l == r) {
            t[u].val.M[1][1] = 1;
            t[u].val.M[1][2] = a[l];
            t[u].val.M[1][3] = 1ll * a[l] * a[l] % mod;
            t[u].val.M[1][4] = 1ll * a[l] * a[l] % mod;
            return ;
        }
        int mid = l + r >> 1;
        build(u << 1, l, mid);
        build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
    void add(int u, int l, int r, int v) {
        if (t[u].l >= l && t[u].r <= r) {
        	Matrix tmp;
        	tmp.Form(v);
        	t[u].val = t[u].val * tmp;
            t[u].add = t[u].add * tmp;
            return ;
        }
        pushdown(u);
        int mid = t[u].l + t[u].r >> 1;
        if (l <= mid) add(u << 1, l, r, v);
        if (r > mid) add(u << 1 | 1, l, r, v);
        pushup(u);
    }

    int query(int u, int l, int r) {
        if (t[u].l >= l && t[u].r <= r) {
            return t[u].val.M[1][4];
        }
        pushdown(u);
        int res = 0;
        int mid = t[u].l + t[u].r >> 1;
        if (l <= mid) res = (res + query(u << 1, l, r)) % mod;
        if (mid < r) res = (res + query(u << 1 | 1, l, r)) % mod;
        return res;
    }
    void add(int l, int r, int v) {
        add(1, l, r, v);
    }
    int query(int l, int r) {
        return query(1, l, r); // D, history sum.
    }
};

int main() {
	int n, m, q;
	std::cin >> n >> m >> q;
	std::vector<int> a(n + 1);
	for (int i = 1; i <= n; i ++) {
		std::cin >> a[i];
		a[i] = (a[i] + mod) % mod;
	}
	SegmentTree t;
	t.init(n, a);

	std::vector<std::array<int, 3> > op(m + 1);
	for (int i = 1; i <= m; i ++) {
		std::cin >> op[i][0] >> op[i][1] >> op[i][2];
		op[i][2] = (op[i][2] + mod) % mod;
	}
	std::vector<std::vector<std::array<int, 4> > > p(m + 1);
	std::vector<int> ans(q + 1);
	for (int i = 1; i <= q; i ++) {
		int l, r, x, y;
		std::cin >> l >> r >> x >> y;
		if (x - 1 >= 0) p[x - 1].push_back({-1, i, l, r});
		p[y].push_back({1, i, l, r});
	}

	for (int i = 0; i <= m; i ++) {
		if (i) {
			int l = op[i][0], r = op[i][1], v = op[i][2];
			t.add(l, r, v);
			if (l - 1 >= 1) t.add(1, l - 1, 0);
			if (r + 1 <= n) t.add(r + 1, n, 0);
		}
		for (auto it : p[i]) {
			int sig = it[0], j = it[1], l = it[2], r = it[3];
			int val = t.query(l, r);
			//std::cout << ans[j] << ' ' << val << ' ' << l << ' ' << r << ' ' << "???\n";
			ans[j] = (ans[j] + val * sig) % mod;
		}
		//std::cout << "TEST : " << t.query(4, 4) << '\n';
	}
	for (int i = 1; i <= q; i ++) {
		ans[i] = (ans[i] + mod) % mod;
		std::cout << ans[i] << '\n';
	}
	return 0;
}
/*
4 1 1
2 3 2 2
1 1 6
4 4 0 1

*/