#include <iostream>
#include <vector>
#include <array>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <tuple>
#include <bitset>
#include <memory>
#include <cmath>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <numeric>
#include <climits>
#include <cfloat>
#include <cassert>

long long int gcd(const long long int a, const long long int b) {
	return (b == 0) ? a : gcd(b, a % b);
}
int main() {
	while (true) {
		int n; std::cin >> n; if (n == 0) break;
		std::vector<long long int> numbers(n * (n + 1) / 2), even; for (auto& b : numbers) std::cin >> b;
		std::copy_if(numbers.begin(), numbers.end(), std::back_inserter(even), [](const long long int n) {return n % 2 == 0; });
		std::sort(even.begin(), even.end());
		long long int odd_min = LLONG_MAX;
		for (const auto& b : numbers) if (b % 2 == 1) odd_min = std::min(odd_min, b);
		const auto a0g = gcd(even[0], even[1]);
		const auto ab = (even[0] / a0g) * (even[1] / a0g);
		const auto gcd_square = odd_min / ab;
		const auto gcd = static_cast<int>(std::sqrt(gcd_square));
		const auto a0 = a0g / gcd;
		std::cout << a0 << '\n';
		for (auto i = 0; i < even.size(); ++i) {
			if (i != 0) std::cout << ' ';
			std::cout << even[i] / a0;
		}
		std::cout << '\n';
	}
}

### Prompt

Please create a solution in cpp to the following problem:

Problem H: Squid Multiplication

Squid Eiko loves mathematics. Especially she loves to think about integer. One day, Eiko found a math problem from a website.

"A sequence b ={ai + aj | i < j } is generated from a sequence a ={a0 , ... , an | ai is even if i is 0, otherwise ai is odd}. Given the sequence b , find the sequence a ."

This problem is easy for Eiko and she feels boring. So, she made a new problem by modifying this problem .

"A sequence b ={ai *aj | i < j } is generated from a sequence a ={ a0, ... , an | ai is even if  i  is 0, otherwise ai is odd}. Given the sequence b , find the sequence a ."

Your task is to solve the problem made by Eiko.



Input

Input consists of multiple datasets.
Each dataset is given by following formats.


n
b0 b1 ... bn*(n+1)/2-1


n is the number of odd integers in the sequence a. The range of n is 2 ≤ n ≤ 250. bi is separated by a space. Each bi is 1 ≤ bi ≤ 263-1. The end of the input consists of a single 0.

Output

For each dataset, you should output two lines. First line contains a0, an even number in the sequence a. The second line contains n odd elements separated by a space. The odd elements are sorted by increasing order. You can assume that the result is greater than or equal to 1 and less than or equal to 231-1.

Example

Input

3
6 10 14 15 21 35
2
30 42 35
0


Output

2
3 5 7
6
5 7

### Response

```cpp
#include <iostream>
#include <vector>
#include <array>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <tuple>
#include <bitset>
#include <memory>
#include <cmath>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <numeric>
#include <climits>
#include <cfloat>
#include <cassert>

long long int gcd(const long long int a, const long long int b) {
	return (b == 0) ? a : gcd(b, a % b);
}
int main() {
	while (true) {
		int n; std::cin >> n; if (n == 0) break;
		std::vector<long long int> numbers(n * (n + 1) / 2), even; for (auto& b : numbers) std::cin >> b;
		std::copy_if(numbers.begin(), numbers.end(), std::back_inserter(even), [](const long long int n) {return n % 2 == 0; });
		std::sort(even.begin(), even.end());
		long long int odd_min = LLONG_MAX;
		for (const auto& b : numbers) if (b % 2 == 1) odd_min = std::min(odd_min, b);
		const auto a0g = gcd(even[0], even[1]);
		const auto ab = (even[0] / a0g) * (even[1] / a0g);
		const auto gcd_square = odd_min / ab;
		const auto gcd = static_cast<int>(std::sqrt(gcd_square));
		const auto a0 = a0g / gcd;
		std::cout << a0 << '\n';
		for (auto i = 0; i < even.size(); ++i) {
			if (i != 0) std::cout << ' ';
			std::cout << even[i] / a0;
		}
		std::cout << '\n';
	}
}

```