动态规划：Codeforces Round #427 (Div. 2) C Star sky

C. Star sky

time limit per test2 seconds
memory limit per test256 megabytes
inputstandard input
outputstandard output

Problem Description

The Cartesian coordinate system is set in the sky. There you can see n stars, the i-th has coordinates (xi, yi), a maximum brightness c, equal for all stars, and an initial brightness si (0 ≤ si ≤ c).

Over time the stars twinkle. At moment 0 the i-th star has brightness si. Let at moment t some star has brightness x. Then at moment (t + 1) this star will have brightness x + 1, if x + 1 ≤ c, and 0, otherwise.

You want to look at the sky q times. In the i-th time you will look at the moment ti and you will see a rectangle with sides parallel to the coordinate axes, the lower left corner has coordinates (x1i, y1i) and the upper right — (x2i, y2i). For each view, you want to know the total brightness of the stars lying in the viewed rectangle.

A star lies in a rectangle if it lies on its border or lies strictly inside it.

Input

The first line contains three integers n, q, c (1 ≤ n, q ≤ 105, 1 ≤ c ≤ 10) — the number of the stars, the number of the views and the maximum brightness of the stars.

The next n lines contain the stars description. The i-th from these lines contains three integers xi, yi, si (1 ≤ xi, yi ≤ 100, 0 ≤ si ≤ c ≤ 10) — the coordinates of i-th star and its initial brightness.

The next q lines contain the views description. The i-th from these lines contains five integers ti, x1i, y1i, x2i, y2i (0 ≤ ti ≤ 109, 1 ≤ x1i < x2i ≤ 100, 1 ≤ y1i < y2i ≤ 100) — the moment of the i-th view and the coordinates of the viewed rectangle.

Output

For each view print the total brightness of the viewed stars.

Examples

input

2 3 3
1 1 1
3 2 0
2 1 1 2 2
0 2 1 4 5
5 1 1 5 5

3 4 5
1 1 2
2 3 0
3 3 1
0 1 1 100 100
1 2 2 4 4
2 2 1 4 7
1 50 50 51 51

output

3
0
3

3
3
5
0

Note

Let’s consider the first example.

At the first view, you can see only the first star. At moment 2 its brightness is 3, so the answer is 3.

At the second view, you can see only the second star. At moment 0 its brightness is 0, so the answer is 0.

At the third view, you can see both stars. At moment 5 brightness of the first is 2, and brightness of the second is 1, so the answer is 3.

---

解题心得：

1. 题意就是说在一个二维平面内有n个点，每个点有一个数值，在初始时刻数值为s，每过一秒数值增加1，数值不超过c，当超过c时数值变为0，然后再次循环。询问q次，每次询问在t时刻从（x1,y1）到(x2,y2)的区域所有点的数值总和是多少。
2. 这个题很明显，数据量大的只有询问的次数，所以肯定是要预处理的，这样才能避过这么大的数据量。预处理就是一个动态规划，dp[t][i][j]表示在t时刻第i行第j列到（0，0）的区域亮度总和，因为t<=10,所以关于t直接遍历就可以了，然后就是周期是c已经告诉了，就很简单了。
3. 动态规划的部分有点像：http://blog.csdn.net/yopilipala/article/details/73691996，但是要更假单得多。没想到动态规划的凭借思维都可以过这个题。

---

/*
在写代码实现相关过程中最好画一个图，以免出现计算重复部分
或者计算出现缺漏
*/

#include<bits/stdc++.h>
using namespace std;
int maps[15][110][110];
int main()
{
    int n,q,c;
    scanf("%d%d%d",&n,&q,&c);
    while(n--)
    {
        int x,y,va;
        scanf("%d%d%d",&x,&y,&va);
        for(int i=0; i<=10; i++)
            maps[i][x][y] += (va+i)%(c+1);
    }

    for(int k=0; k<=10; k++)
        for(int i=1; i<=100; i++)
            for(int j=1; j<=100; j++)
                maps[k][i][j] += maps[k][i-1][j]+maps[k][i][j-1]-maps[k][i-1][j-1];//多减去的要加回来，容斥原理
    while(q--)
    {
        int time,x1,y1,x2,y2;
        scanf("%d%d%d%d%d",&time,&x1,&y1,&x2,&y2);
        time %= (c+1);
        printf("%d
",maps[time][x2][y2] - maps[time][x1-1][y2]-maps[time][x2][y1-1]+maps[time][x1-1][y1-1]);//多减去的要加回来，容斥原理
    }
    return 0;
}