Alexey is trying to develop a program for a very simple microcontroller. It makes readings from various sensors over time, and these readings must happen at specific regular times. Unfortunately, if two of these readings occur at the same time, the microcontroller freezes and must be reset.

There are N different sensors that read data on a regular basis. For each i from 1 to N, the reading from sensor i will occur every Ai milliseconds with the first reading occurring exactly Ai milliseconds after the microcontroller is powered up. Each reading takes precisely one millisecond on Alexey's microcontroller.

Alexey wants to know when the microcontroller will freeze after he turns it on.

**Input**
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.

The first line contains single integer N denoting the number of sensors.

The second line contains N space-separated integers A1, A2, ..., AN denoting frequency of measurements. Namely, sensor i will be read every Ai milliseconds with the first reading occurring Ai milliseconds after the microcontroller is first turned on.

**Output**
For each test case, output a single line containing the number of milliseconds until the microcontroller freezes.

**Constraints**
1 ≤ T ≤ 10

2 ≤ N ≤ 500

1 ≤ Ai ≤ 10^9

**Example**
**Input:**
3

3

2 3 5

4

1 8 7 11

4

4 4 5 6

**Output:**
6

7

4

And time limit is 1 second.

**What I have tried:**
I came up with the following code :-

#include<stdio.h>
int main(void)
{
int t, n, i, flag;
scanf("%d", &t);
while(t--)
{
scanf("%d", &n);
long a[n], time;
scanf("%ld", &a[0]);
time = a[0];
for(i = 1; i < n; i++){
scanf("%ld", &a[i]);
if(a[i] < time)
time = a[i];
}
flag = 0;
while(flag != 2)
{
flag = 0;
for(i = 0; i < n; i++)
{
if(time % a[i] == 0)
flag++;
if(flag == 2)
break;
}
if(flag != 2)
time++;
}
printf("%ld\n", time);
}
return 0;
}

But the time limit of 1 second is exceeding. Can anyone suggest a faster method to solve this problem ?

Tip: try to limit all input.