A computer processor is given N tasks to perform (1 ≤ N ≤ 50,000). The i-th task requires Ti seconds of processing time (1 ≤ Ti ≤ 1,000,000,000). The processor runs the tasks as follows: each task is run in order, from 1 to N, for 1 second, and then the processor repeats this again starting from task 1. Once a task has been completed, it will not be run in later iterations. Determine, for each task, the total running time elapsed once the task has been completed.

Input

The first line of the input contains the integer N, and the next N lines contain the integers T1 through TN.

Output

Output N lines, the i-th of which contains an integer representing the time elapsed when task i has been processed.

Example

**Input:**

5

8

1

3

3

8

**Output:**

22

2

11

12

23

The second task is completed during the first iteration, finishing 2 seconds in. On the third iteration, the third and fourth tasks complete at 11 seconds and 12 seconds, respectively. Finally, on the eighth iteration, the first and last tasks complete at 22 seconds and 23 seconds, respectively.

what cud the approach??

This is my code:

```
#include <iostream>
using namespace std;
int main()
{
int n;
cin>>n;
int a[n];
int total=0;
for(int i=0;i<n;i++)
{cin>>a[i];total+=a[i];}
int b[n];
int j=0;
for(int i=0;i<total;i++)
{
while(a[j%n]==0) j++;
a[j%n]-=1;
if(a[j%n]==0) b[j%n]=i+1; j++;
}
for(int i=0;i<n;i++)
cout<<b[i]<<endl;
system("pause");
return 0;
}
```

but this not getting accepted on spoj…

## Best Solution

First of all, as Chakradar Raju said, to emulate the whole procedure is not an good way to implement the job for its huge range. And you need to use types that has wider range than int, for example something like long long which is a 64bit int.

And then try to find a good algorithm to work it out. I'll provide a method, and wish it work.

Every time, we consider a task numbered i, and when it comes to the last second of ith task, all the tasks shorter than it has finished. We only need to sum their cost up. For the tasks not shorter than ith task, we assume the ith task takes Ti seconds. The tasks not shorter than it and the ith task itself both work for (Ti - 1) seconds, and for their own (Ti)th of processing, only the tasks before the ith task works. Sum them up, and you'll get the answer.

Take the sample as an example:

For the 1st task, it takes 8 seconds, and the tasks shorter than it has 1 + 3 + 3 = 7 seconds, then it takes 7 seconds for it and the 5th task, so the value is 7 * 2 = 14 seconds. Then there's no task before ith task, so we only need to add 1 second for the 1st task itself. The result is 7 + 14 + 1 = 22

Maybe it's not clear enough, let's look at the 3rd task, it takes 3 seconds, and only 1 task is shorter than it(the second one which takes 1 second). And all the left tasks take the 3 - 1 = 2 seconds, it's 4 * 2 = 8 seconds. Finally, there's only one task left before it, so only it runs the 3rd time. We add it and the 3rd time processing itself. The result is 1 + 8 + 1 + 1 = 11 seconds.

When coding, you need to remember the sequence number of a task and sort them by their processing time. Then all the tasks short then them are before it. The left job is a linear time processing, and the sort takes O(nlogn) time complexity, which is fast enough to finish the job.