Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table $M$ with $n$ rows and $n$ columns such that $M_{ij}=a_i \cdot a_j$ where $a_1, \dots, a_n$ is some sequence of positive integers.

Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array $a_1, \dots, a_n$. Help Sasha restore the array!


-----Input-----

The first line contains a single integer $n$ ($3 \leqslant n \leqslant 10^3$), the size of the table. 

The next $n$ lines contain $n$ integers each. The $j$-th number of the $i$-th line contains the number $M_{ij}$ ($1 \leq M_{ij} \leq 10^9$). The table has zeroes on the main diagonal, that is, $M_{ii}=0$.


-----Output-----

In a single line print $n$ integers, the original array $a_1, \dots, a_n$ ($1 \leq a_i \leq 10^9$). It is guaranteed that an answer exists. If there are multiple answers, print any.


-----Examples-----
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0

Output
2 2 3 1 2 
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0

Output
9999 10000 9998

Difficulty: EASY
Tags: Number theory

Mathematics

Starter code:

Solutions:
n = int(input())
l1 = []
for _ in range(n):
	l1.append([int(x) for x in input().split()])
p = (l1[0][1] * l1[0][2] // l1[1][2]) ** 0.5
print(int(p), end=' ')
for i in range(1, n):
	print(int(l1[0][i] // p), end=' ')


from collections import deque, Counter
import array
from itertools import combinations, permutations
from math import sqrt
import unittest

def read_int():
	return int(input().strip())

def read_int_array():
	return [int(i) for i in input().strip().split(' ')]
n = read_int()
M = []
for i in range(n):
	M += [read_int_array()]
a2 = int((M[1][2] * M[0][1] / M[0][2]) ** 0.5)
a1 = int(M[0][1] / a2)
A = [a1, a2]
for i in range(2, n):
	A += [int(M[0][i] / a1)]
print(' '.join((str(i) for i in A)))


n = int(input())
m = [list(map(int, input().split())) for i in range(n)]
if n == 1:
	print(m[0][0])
elif n == 2:
	print(1, m[0][1])
else:
	ansl = [None] * n
	for i in range(n - 2):
		ansl[i + 1] = int((m[i][i + 1] * m[i + 1][i + 2] // m[i][i + 2]) ** (1 / 2))
	ansl[0] = m[0][1] // ansl[1]
	ansl[-1] = m[-2][-1] // ansl[-2]
	print(' '.join(map(str, ansl)))


from math import sqrt
n = int(input())
matriz = [[] for e in range(n)]
a = [[] for e in range(n)]
for i in range(n):
	linha = list(map(int, input().split()))
	for j in range(len(linha)):
		matriz[i].append(linha[j])
		if i == 0 and j == 2:
			m02 = linha[j]
		elif i == 0 and j == 1:
			m01 = linha[j]
		elif i == 1 and j == 2:
			m12 = linha[j]
a[2] = int(sqrt(m12 * m02 / m01))
a[1] = int(m12 / a[2])
a[0] = int(m02 / a[2])
for i in range(3, len(matriz[0])):
	a[i] = int(matriz[0][i] / a[0])
print(*a)


n = int(input())
grid = []
for i in range(n):
	tmp = input().split()
	tmp = [int(x) for x in tmp]
	grid.append(tmp)
a = int((grid[0][1] * grid[0][2] // grid[1][2]) ** 0.5)
ans = [a]
for i in range(1, n):
	ans.append(grid[0][i] // a)
outputBuffer = ''
for x in ans:
	outputBuffer += str(x) + ' '
print(outputBuffer)


from math import sqrt
n = int(input())
table = [[] for x in range(n)]
for i in range(n):
	table[i] = list(map(int, input().split()))
x = table[0][1]
y = table[0][2]
z = table[1][2]
a = [0 for x in range(n)]
a[1] = int(sqrt(x * z / y))
a[0] = x // a[1]
a[2] = z // a[1]
for i in range(3, n):
	a[i] = table[i][1] // a[1]
print(*a)


n = int(input())
M = [list(map(int, input().split())) for i in range(n)]
a1 = int((M[1][0] * M[2][0] / M[2][1]) ** 0.5)
a2 = M[0][1] // a1
A = []
for i in range(2, n):
	A.append(int((M[i - 2][i] * M[i - 1][i] / M[i - 2][i - 1]) ** 0.5))
A = [a1, a2] + A
print(*A)


import os
import math

def f(matr):
	result = [0] * len(matr)
	result[0] = int(math.sqrt(matr[0][1] * matr[0][2] / matr[1][2]))
	for i in range(1, len(matr)):
		result[i] = int(matr[i][i - 1] / result[i - 1])
	return ''.join((str(e) + ' ' for e in result))
if os.environ.get('DEBUG', False):
	print(f'{f([[0, 4, 6, 2, 4], [4, 0, 6, 2, 4], [6, 6, 0, 3, 6], [2, 2, 3, 0, 2], [4, 4, 6, 2, 0]])} = 2 2 3 1 2 ')
	print(f'{f([[0, 99990000, 99970002], [99990000, 0, 99980000], [99970002, 99980000, 0]])} = 9999 10000 9998 ')
else:
	n = int(input())
	print(f([list(map(int, input().split())) for _ in range(n)]))


import math
n = int(input())
m = [list(map(int, input().split())) for i in range(n)]
ans = [int(math.sqrt(m[0][1] * m[0][2] // m[1][2]))]
for i in range(n - 2):
	j = i + 1
	ans.append(m[i][j] // int(math.sqrt(m[i][j] * m[i][j + 1] // m[i + 1][j + 1])))
ans.append(m[i + 1][j + 1] // ans[-1])
print(*ans)


from math import *
n = int(input())
v = []
for i in range(n):
	s = list(map(int, input().split()))
	v.append(s)
ans = []
for i in range(1, int(sqrt(v[0][1])) + 2):
	if v[0][1] % i == 0:
		ans = []
		j = 1
		ans.append(i)
		while j < n:
			if v[0][j] % i == 0:
				ans.append(v[0][j] // i)
			else:
				break
			j += 1
		f = False
		if len(ans) == n:
			f = True
			for i1 in range(1, n - 1):
				for i2 in range(i1 + 1, n):
					if v[i1][i2] != ans[i1] * ans[i2]:
						f = False
			if f == True:
				print(*ans)
				exit()
	if v[0][1] % i == 0:
		s1 = v[0][1] // i
		if v[0][1] % s1 == 0:
			ans = []
			j = 1
			ans.append(s1)
			while j < n:
				if v[0][j] % s1 == 0:
					ans.append(v[0][j] // s1)
				else:
					break
				j += 1
			f = False
			if len(ans) == n:
				f = True
				for i1 in range(1, n - 1):
					for i2 in range(i1 + 1, n):
						if v[i1][i2] != ans[i1] * ans[i2]:
							f = False
				if f == True:
					print(*ans)
					exit()
i = v[0][1]
if v[0][1] % i == 0:
	ans = []
	j = 1
	ans.append(i)
	while j < n:
		if v[0][j] % i == 0:
			ans.append(v[0][j] // i)
		else:
			break
		j += 1
	f = False
	if len(ans) == n:
		f = True
		for i1 in range(1, n):
			for i2 in range(i1 + 1, n):
				if v[i1][i2] != ans[i1] * ans[i2]:
					f = False
		if f == True:
			print(*ans)
			exit()
	if v[0][1] % i == 0:
		s1 = v[0][1] // i
		if v[0][1] % s1 == 0:
			ans = []
			j = 1
			ans.append(s1)
			while j < n:
				if v[0][j] % s1 == 0:
					ans.append(v[0][j] // s1)
				else:
					break
				j += 1
			f = False
			if len(ans) == n:
				f = True
				for i1 in range(1, n - 1):
					for i2 in range(i1 + 1, n):
						if v[i1][i2] != ans[i1] * ans[i2]:
							f = False
				if f == True:
					print(*ans)
					exit()


import math
n = int(input())
a = []
for i in range(n):
	b = list(map(int, input().split()))
	a.append(b)
x = a[0][1] * a[0][2] // a[1][2]
d = math.sqrt(x)
print(int(d), end=' ')
for i in range(1, n):
	print(int(a[0][i] // d), end=' ')


import math
n = int(input())
arr2 = []
arr = []
for _ in range(n):
	arr2.append(list(map(int, input().split())))
x = arr2[1][0]
y = arr2[2][0]
z = arr2[2][1]
a1 = int(math.sqrt(x * y // z))
arr.append(a1)
for h in range(1, n):
	arr.append(arr2[h][0] // arr[0])
print(*arr)


from math import sqrt
n = int(input())
l = []
for i in range(n):
	ll = list(map(int, input().split()))
	l.append(ll)
res = []
for i in range(n - 2):
	res.append(int(sqrt(l[i][-1] * l[i][-2] // l[-1][-2])))
res.append(int(sqrt(l[-2][0] * l[-2][-1] // l[0][-1])))
res.append(int(sqrt(l[-1][0] * l[-1][1] // l[0][1])))
print(*res)


def createTransitions(strSet, pat):
	patDict = {0: {}}
	stateCount = 0
	flag = True
	i = 0
	while i < len(pat) - 1:
		flag = True
		if pat[i + 1] == '*':
			if pat[i] == '.':
				for elem in strSet:
					patDict[stateCount][elem] = stateCount
			else:
				patDict[stateCount][pat[i]] = stateCount
			i = i + 2
			if i >= len(pat):
				break
			flag = False
			if pat[i] == '.':
				for elem in strSet:
					patDict[stateCount][elem] = stateCount + 1
			else:
				patDict[stateCount][pat[i]] = stateCount + 1
		else:
			if pat[i] == '.':
				for elem in strSet:
					patDict[stateCount][elem] = stateCount + 1
			else:
				patDict[stateCount][pat[i]] = stateCount + 1
			i += 1
		stateCount += 1
		patDict[stateCount] = {}
	if flag:
		if pat[i] == '.':
			for elem in strSet:
				patDict[stateCount][elem] = stateCount + 1
		else:
			patDict[stateCount][pat[i]] = stateCount + 1
		stateCount += 1
		patDict[stateCount] = {}
	return (patDict, stateCount)

def solve(str: str, pat: str) -> list:
	(transition, final) = createTransitions(set(str), pat)
	currState = 0
	for char in str:
		currState = transition[currState].get(char, -1)
		if currState == -1:
			return False
	return currState == final

def test_solve():
	assert solve('aa', '.a') == True
	assert solve('ab', '.a') == False
	assert solve('aaa', '.a') == False
	assert solve('aa', 'a') == False
	assert solve('aa', 'a.') == True
	assert solve('aab', '.ab') == True
	assert solve('aab', 'c*a*b') == True
	assert solve('mississippi', 'mis*is*p*.') == False
test_solve()
from math import sqrt
n = int(input())
arr = list(map(int, input().split()))
key = list(map(int, input().split()))[2]
for _ in range(2, n):
	input()
arr[0] = int(sqrt(arr[1] * arr[2] // key))
print(arr[0], end=' ')
for i in arr[1:]:
	print(i // arr[0], end=' ')


n = int(input())
arr = []
s = ''
for i in range(n):
	arr.append(list(map(int, input().split())))
for i in range(n):
	if i == 0:
		temp = arr[1][0] * arr[2][0]
		arr[0][0] = int((temp // arr[1][2]) ** 0.5)
		s += str(arr[0][0]) + ' '
	elif i == n - 1:
		temp = arr[n - 2][n - 1] * arr[n - 3][n - 1]
		arr[n - 1][n - 1] = int((temp // arr[n - 3][n - 2]) ** 0.5)
		s += str(arr[n - 1][n - 1]) + ' '
	else:
		temp = arr[i - 1][i] * arr[i + 1][i]
		arr[i][i] = int((temp // arr[i - 1][i + 1]) ** 0.5)
		s += str(arr[i][i]) + ' '
print(s)


x = int(input())
li = [[0 for i in range(x)] for j in range(x)]
for i in range(x):
	li1 = [int(j) for j in input().split()]
	li[i][0:x] = li1[0:x]
a = li
k = int(pow(a[0][1] * a[0][2] // a[1][2], 1 / 2))
s = '' + str(k) + ' '
for i in range(1, x):
	s = s + str(li[0][i] // k) + ' '
print(s)
quit()


numb = int(input())
lst = list(map(int, input().split()))
lst1 = list(map(int, input().split()))
for i in range(numb - 2):
	lst2 = list(map(int, input().split()))
x = int((lst[1] * lst[2] / lst1[2]) ** 0.5)
for i in lst:
	if i == 0:
		print(x, end=' ')
	else:
		print(int(i / x), end=' ')


n = int(input())
T = []
for i in range(n):
	T.append([int(i) for i in input().split()])
Ans = [0] * n
Ans[0] = int((T[0][1] * T[0][2] // T[1][2]) ** 0.5)
for i in range(1, n):
	Ans[i] = T[0][i] // Ans[0]
print(*Ans)


from math import sqrt
n = int(input())
m = list()
for i in range(n):
	b = list(map(int, input().split()))
	m.append(b)
a = [0] * n
a[2] = m[0][2] * m[1][2] / m[0][1]
a[2] = int(sqrt(a[2]))
a[0] = m[0][2] / a[2]
a[1] = m[1][2] / a[2]
for i in range(3, n):
	a[i] = m[i - 1][i] // a[i - 1]
for x in a:
	print(int(x), end=' ')


from math import sqrt
n = int(input())
l = []
for i in range(n):
	s = list(map(int, input().split()))
	l.append(s)
s1 = l[0][1] * l[0][2]
s2 = l[1][0] * l[1][2]
k = s1 / s2
t = l[0][1]
r = sqrt(t / k)
r1 = int(t / r)
r1 = int(r1)
print(r1, end=' ')
for i in range(1, n):
	print(int(l[0][i] / r1), end=' ')


from math import *
n = int(input())
v = [[] for i in range(n)]
for i in range(n):
	for j in input().split():
		v[i].append(int(j))
a = [0 for i in range(n)]
a[0] = int(sqrt(v[0][1] * v[0][2] // v[1][2]))
for i in range(1, n):
	a[i] = v[0][i] // a[0]
print(*a)


import sys
input = sys.stdin.readline
from math import sqrt
n = int(input())
m = []
for i in range(n):
	m.append([int(i) for i in input().split()])
p12 = m[0][1]
p13 = m[0][2]
p23 = m[1][2]
p = int(sqrt(p12 * p13 * p23))
x1 = p // p23
print(x1, end=' ')
for i in range(1, n):
	print(m[0][i] // x1, end=' ')
print()


n = int(input())
A1 = list(map(int, input().split()))
a2a3 = list(map(int, input().split()))[2]
for i in range(n - 2):
	c = input()
a1a2 = A1[1]
a1a3 = A1[2]
while a1a2 % a1a3 != 0 and a1a3 % a1a2 != 0:
	(a1a2, a1a3) = (a1a3 % a1a2, a1a2 % a1a3)
d = min(a1a2, a1a3)
b1b1 = a2a3 / (A1[1] * A1[2] / d / d)
b1 = 0
while (b1 + 1) * (b1 + 1) <= b1b1:
	b1 += 1
a1 = d // b1
print(a1, end=' ')
for i in range(1, n):
	print(A1[i] // a1, end=' ')


x = int(input())
mass = []
for i in range(x):
	l = list(map(int, input().split()))
	mass += [l]
res = [0 for i in range(x)]
res[0] = int((mass[0][1] * mass[0][2] // mass[1][2]) ** 0.5)
for i in range(1, x):
	res[i] = int(mass[0][i] // res[0])
print(*res)


import math
n = int(input())
a = [list(map(int, input().split())) for _ in range(n)]
b = []
for i in range(n):
	b += (int(math.sqrt(a[i - 1][i] * a[i][(i + 1) % n] // a[i - 1][(i + 1) % n])),)
print(' '.join(map(str, b)))


n = int(input())
a = [[int(x) for x in input().split()] for _ in range(n)]
l = int((a[0][1] * a[0][2] * a[1][2]) ** (1 / 2))
ans = l // a[1][2]
print(ans, end=' ')
for i in range(1, n):
	print(a[0][i] // ans, end=' ')


import math
ans = []
size = int(input())
matrix = []
for i in range(size):
	matrix.append(list(map(int, input().split())))
if size > 3:
	for i in range(size):
		if i < size / 2:
			ans.append(round(math.sqrt(matrix[i][i + 1] * (matrix[i][i + 2] / matrix[i + 1][i + 2]))))
		else:
			ans.append(round(math.sqrt(matrix[i][i - 1] / (matrix[i - 1][i - 2] / matrix[i][i - 2]))))
else:
	a2 = int(math.sqrt(matrix[1][2] * (matrix[0][1] / matrix[0][2])))
	a1 = int(matrix[0][1] / a2)
	a3 = int(matrix[1][2] / a2)
	ans = [a1, a2, a3]
print(' '.join(list(map(str, ans))))


n = int(input())
a = []
for i in range(n):
	t = list(map(int, input().split()))
	a.append(t)
x2 = int((a[0][1] * a[1][2] // a[0][2]) ** 0.5)
x1 = int(a[0][1] // (a[0][1] * a[1][2] // a[0][2]) ** 0.5)
for i in range(n):
	if i == 0:
		print(x1, end=' ')
	elif i == n - 1:
		print(a[0][i] // x1)
	else:
		print(a[0][i] // x1, end=' ')


from sys import setcheckinterval, stdin, setrecursionlimit
setcheckinterval(1000)
setrecursionlimit(10 ** 7)

def iin():
	return int(stdin.readline())

def lin():
	return list(map(int, stdin.readline().split()))
n = iin()
arr = [lin() for i in range(n)]
a1 = arr[0][1] * arr[0][2]
a1 //= arr[1][2]
from math import sqrt
i = int(sqrt(a1))
ans = [i]
for j in range(1, n):
	ans.append(arr[0][j] // i)
print(*ans)


from math import sqrt
n = int(input())
A = []
for _ in range(n):
	arr = [int(x) for x in input().split(' ')]
	A.append(arr)
a1 = int(sqrt(A[0][2] * A[0][1] // A[1][2]))
print(a1, end=' ')
for x in A[0][1:]:
	print(x // a1, end=' ')


n = int(input())
L = []
for i in range(0, n):
	M = list(map(int, input().split()))
	L.append(M)
N = [0] * n
x = L[0][1]
y = L[0][2]
z = L[1][2]
r = int((x * y * z) ** 0.5)
N[0] = r // z
N[1] = r // y
N[2] = r // x
for i in range(3, n):
	N[i] = L[0][i] // N[0]
print(*N)


import math
from math import gcd as g
n = int(input())
h = [[0] * n for i in range(n)]
for i in range(n):
	b = list(map(int, input().rstrip().split()))
	for j in range(n):
		h[i][j] = b[j]
gcd = h[0][1]
for i in range(2, n):
	gcd = g(gcd, h[0][i])
if gcd == 1 or gcd == 2 or gcd == 3:
	f = [1, gcd]
	for k in range(len(f)):
		p = []
		p.append(f[k])
		for j in range(1, n):
			p.append(h[0][j] // f[k])
		flag = 0
		ans = f[k]
		for i in range(n):
			for j in range(n):
				if i != j:
					if h[i][j] != p[i] * p[j]:
						flag = 1
						break
			if flag == 1:
				break
		if flag == 0:
			ans = f[k]
			break
	print(*p)
	exit()
f = []
for i in range(2, math.ceil(math.sqrt(gcd)) + 1):
	if gcd % i == 0:
		if gcd / i == i:
			f.append(i)
		else:
			f.append(i)
			f.append(gcd // i)
p = []
f.append(gcd)
f.append(1)
for k in range(len(f)):
	p = []
	p.append(f[k])
	for j in range(1, n):
		p.append(h[0][j] // f[k])
	flag = 0
	ans = f[k]
	for i in range(n):
		for j in range(n):
			if i != j:
				if h[i][j] != p[i] * p[j]:
					flag = 1
					break
		if flag == 1:
			break
	if flag == 0:
		ans = f[k]
		break
print(*p)


n = int(input())
m = []
for i in range(n):
	m.append(list(map(int, input().split())))
for i in range(n):
	p = set(range(0, n))
	p.discard(i)
	(i1, i2) = (p.pop(), p.pop())
	print(round((m[i][i1] * m[i][i2] // m[i1][i2]) ** 0.5), end=' ')


n = int(input())
a = [list(map(int, input().split())) for _ in range(n)]
ans = [int((a[0][1] * a[0][2] // a[1][2]) ** 0.5)]
for i in a[0][1:]:
	ans.append(i // ans[0])
print(*ans)


n = int(input())
grid = []
for i in range(n):
	grid.append(list(map(int, input().split())))
a = grid[0][1]
b = grid[0][2]
c = grid[1][2]
a3 = int((b * c // a) ** 0.5)
a1 = b // a3
a2 = a // a1
l = [a1, a2, a3]
i = 3
while i < n:
	l.append(grid[0][i] // a1)
	i += 1
print(*l)


import os
import sys
from io import BytesIO, IOBase
from math import sqrt

def solution():
	pass

def main():
	n = r_int()
	mat = []
	for i in range(n):
		if i == 0:
			row = r_array()
			(ab, ac) = (row[1], row[2])
		elif i == 1:
			row = r_array()
			bc = row[2]
		else:
			row = r_array()
		mat.append(row)
	res = int(sqrt(ab * ac / bc))
	for i in range(n):
		if i == 0:
			write(res, end=' ')
		else:
			write(mat[0][i] // res, end=' ')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')

def write(*args, end='\n'):
	for x in args[:-1]:
		sys.stdout.write(str(x) + ' ')
	sys.stdout.write(str(args[-1]))
	sys.stdout.write(end)

def r_array():
	return [int(x) for x in input().split()]

def r_int():
	return int(input())
main()


a = int(input())
b = []
c = []
for i in range(a):
	b.append(list(map(int, input().split())))
for i in range(1, a - 1):
	c.append(int((b[i][i - 1] * b[i + 1][i] / b[i + 1][i - 1]) ** 0.5))
c = [int(b[0][1] / c[0])] + c + [int(b[a - 2][a - 1] / c[a - 3])]
print(*c)


I = input
I()
a = [*map(int, I().split())]
a[0] = a[1] * a[2] / int(I().split()[2])
print(*(int(y / a[0] ** 0.5) for y in a))


import math
n = int(input())
a = []
for _ in range(n):
	a.append([int(x) for x in input().split()])
for i in range(0, n - 2):
	x1 = a[i][i + 1]
	x2 = a[i][i + 2]
	x3 = a[i + 1][i + 2]
	x = math.sqrt(x1 * x2 / x3)
	print(int(x), end=' ')
xx = a[0][1]
if n != 3:
	x4 = a[n - 2][0] * a[n - 2][1] / xx
	x5 = a[n - 1][0] * a[n - 1][1] / xx
else:
	x4 = (a[0][1] / x) ** 2
	x5 = a[n - 1][0] * a[n - 1][1] / xx
print(int(math.sqrt(x4)), end=' ')
print(int(math.sqrt(x5)))


n = int(input(''))
a = []
import math
a.append(0)
for i in range(n):
	ip = list(map(int, input('').split(' ')))
	a.append(ip)
ans = [0] * (n + 1)
ans[3] = math.sqrt(a[3][1] * a[3][0] // a[2][0])
ans[2] = a[3][1] // ans[3]
ans[1] = a[3][0] // ans[3]
for i in range(3, n + 1, 1):
	ans[i] = a[i][0] // ans[1]
for i in range(1, n + 1, 1):
	print(int(ans[i]), end=' ')


import math
n = int(input())
a = []
for i in range(n):
	a.append([int(i) for i in input().split()])
x2 = a[0][1] * a[0][2] // a[1][2]
x = int(math.sqrt(x2))
z = [x]
for i in range(1, n):
	z.append(a[0][i] // x)
for i in range(n):
	print(z[i], end=' ')


import math
n = int(input())
l = []
for i in range(n):
	k = [int(y) for y in input().split()]
	l.append(k)
x = l[0][1] * l[0][2]
x = x // l[1][2]
x = math.sqrt(x)
x = int(x)
ans = []
ans.append(x)
for i in range(1, n):
	ans.append(l[0][i] // x)
for i in ans:
	print(i, end=' ')


import math
n = int(input())
rows = n
columns = n
matrix = []
for i in range(0, rows):
	matrix.append(list(map(int, input().rstrip().split())))
result = []
result.append(math.floor(math.sqrt(matrix[0][1] * matrix[0][2] // matrix[1][2])))
for j in range(1, n):
	result.append(matrix[j][0] // result[0])
for k in range(0, n):
	print(result[k], end=' ')


import math

def multiplicationTable():
	n = int(input())
	array = []
	list = [0] * n
	for i in range(n):
		row = input().split(' ')
		newrow = []
		for item in row:
			newrow.append(int(item))
		array.append(newrow)
	for i in range(2, n):
		a = int(math.sqrt(array[0][i] * array[1][i] / array[0][1]))
		list[i] = a
	list[0] = int(array[0][2] / list[2])
	list[1] = int(array[0][1] / list[0])
	result = ''
	for number in list:
		if result == '':
			result = result + str(number)
		else:
			result = result + ' ' + str(number)
	print(result)
multiplicationTable()


import math
n = int(input())
a = []
for _ in range(n):
	l = list(map(int, input().split()))
	a.append(l)
r = math.sqrt(a[0][1] * a[0][2] / a[1][2])
print(int(r), end=' ')
for i in range(1, n):
	print(int(a[0][i] / r), end=' ')


n = int(input())
ar = []
for i in range(n):
	x = list(map(int, input().split()))
	ar.append(x)
print(round((ar[2][0] * ar[0][1] / ar[2][1]) ** (1 / 2)), end=' ')
print(round((ar[2][1] * ar[1][0] / ar[2][0]) ** (1 / 2)), end=' ')
for j in range(2, n):
	print(round((ar[0][j] * ar[j][1] / ar[0][1]) ** (1 / 2)), end=' ')


n = int(input())
a = []
for i in range(n):
	b = [int(i) for i in input().split()]
	a.append(b)
ab = a[0][1]
ac = a[0][2]
bc = a[1][2]
a2 = ab * ac // bc
fir = int(a2 ** 0.5)
print(fir, end=' ')
for i in range(1, len(a[0])):
	print(a[0][i] // fir, end=' ')


import math

def main():
	n = int(input())
	M1 = tuple(map(int, input().split()))
	M2 = tuple(map(int, input().split()))
	for i in range(n - 2):
		M = input()
	a1 = int(math.sqrt(M1[1] * M1[2] / M2[2]))
	a = [a1]
	for i in range(1, n):
		a.append(int(M1[i] / a1))
	for i in a:
		print(i, end=' ')
main()


import math
from sys import stdin, stdout
n = int(stdin.readline())
ar = list(map(int, stdin.readline().split()))
br = list(map(int, stdin.readline().split()))
k = br[2]
a = int(math.sqrt(ar[1] * ar[2] / br[2]))
print(a, end=' ')
for i in range(1, n):
	print(ar[i] // a, end=' ')


import sys
from math import sqrt
first = True
table = []
at = 0
for line in sys.stdin:
	if first:
		n = int(line)
		first = False
		continue
	table.append([int(a) for a in line.split()])
	at += 1
	if at == n:
		break
at = 0
end = ' '
for (i, line) in enumerate(table):
	a_i = int(sqrt(line[i - 1] * line[i - 2] / table[i - 1][i - 2]))
	at += 1
	if at == n:
		end = '\n'
	print(a_i, end=end)


from math import sqrt
n = int(input())
a = []
for i in range(n):
	a.append(list(map(int, input().split())))
a[1][1] = int(sqrt(a[0][1] * a[1][2] // a[0][2]))
ans = []
for i in range(n):
	if i == 1:
		ans.append(a[1][1])
	else:
		ans.append(a[i][1] // a[1][1])
print(*ans)


from sys import stdin
from math import sqrt

def r():
	return stdin.readline().strip()

def r_t(tp):
	return map(tp, r().strip().split())

def r_a(tp):
	return list(r_t(tp))

def main():
	n = int(r())
	M = list()
	for i in range(n):
		M.append(r_a(int))
	ans = list()
	for i in range(n - 2):
		ans.append(sqrt(M[i + 2][i] * M[i + 1][i] // M[i + 2][i + 1]))
	ans.append(sqrt(M[n - 1][n - 2] * M[0][n - 2] // M[n - 1][0]))
	ans.append(sqrt(M[1][n - 1] * M[0][n - 1] // M[0][1]))
	ans = list(map(int, ans))
	print(*ans)
main()


import sys, math
n = int(sys.stdin.readline())
arr = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]
temp = []
factor = set()
ans = [0] * n
for i in range(1, int(arr[0][1] ** 0.5) + 1):
	if arr[0][1] % i == 0:
		factor.add(i)
		factor.add(arr[0][1] // i)
factor = sorted(factor)
for i in factor:
	now = i
	can = True
	ans = [0] * n
	ans[0] = now
	for j in range(n - 1):
		if arr[j][j + 1] % now != 0:
			can = False
			break
		else:
			now = arr[j][j + 1] // now
			ans[j + 1] = now
	if can:
		fin = True
		for j in range(1, n):
			if arr[0][j] != i * ans[j]:
				fin = False
				break
		if fin:
			print(' '.join(map(str, ans)))
			break


n = int(input())
a = [[0]] * n
for i in range(n):
	a[i] = list(map(int, input().split()))
z = a[0][1] * a[0][2] // a[1][2]
l = 0
r = z
while r - l > 1:
	m = (r + l) // 2
	if m * m < z:
		l = m
	else:
		r = m
print(r, end=' ')
for i in range(1, n):
	x = a[i][0] * a[i][0] // z
	l = 0
	r = x
	while r - l > 1:
		m = (r + l) // 2
		if m * m < x:
			l = m
		else:
			r = m
	print(r, end=' ')


n = int(input())
a = []
for i in range(n):
	a.append(list(map(int, input().split())))
b = []
f = (a[n - 3][n - 1] * a[n - 2][n - 1] / a[n - 3][n - 2]) ** (1 / 2)
b.append(f)
for i in range(n - 2, -1, -1):
	b.append(a[n - 1][i] / f)
print(*reversed(list(map(int, b))))


n = int(input())
a = []
for i in range(n):
	a.append(list(map(int, input().split())))
x = a[0][1]
y = a[1][2]
z = a[2][0]
b = []
b.append(int((x * y * z) ** 0.5) // y)
for i in range(1, n):
	b.append(a[0][i] // b[0])
print(*b)


n = int(input())
arr = []
for row in range(n):
	arr.append(list(map(int, input().split())))
for row in range(n):
	i1 = (row + 1) % n
	i2 = (row + 2) % n
	a = arr[row][i1] * arr[row][i2] // arr[i1][i2]
	print(int(a ** 0.5), end=' ')


from math import sqrt
n = int(input())
a = []
b = []
for i in range(n):
	a.append([int(x) for x in input().split()])
b.append(int(sqrt(a[0][1] * a[0][2] // a[1][2])))
for i in range(1, n):
	b.append(a[0][i] // b[0])
for i in range(n):
	print(b[i], end=' ')


import math
n = int(input())
A = []
for i in range(n):
	B = list(map(int, input().split()))
	A.append(B)
a = []
x = int(math.sqrt(A[0][1] * A[0][2] / A[1][2]))
print(x, end=' ')
for i in range(1, n):
	print(int(A[0][i] / x), end=' ')


n = int(input())
t = [[0]]
for k in range(n):
	v = list(map(int, input().split()))
	t.append(v)
f = 0
import math
h = (t[1][1] * t[1][2] // t[2][2]) ** 0.5
v = [int(h)]
for j in range(1, n):
	v.append(int(t[1][j] // h))
print(*v)


from math import sqrt, ceil

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
from collections import defaultdict as dd
n = int(input())
a = []
for _ in range(n):
	a.append([int(i) for i in input().split()])
a1 = a[0][1] * a[0][2]
a1 //= a[1][2]
a1 = int(a1 ** 0.5)
b = a[0].copy()
ans = [a1]
for i in range(1, n):
	ans.append(b[i] // a1)
print(*ans)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import math

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
n = int(input())
dict1 = {}
for j in range(n):
	dict1[j] = list(map(int, input().split()))
ans = [0] * n
prod1 = dict1[n - 2][-1]
prod2 = dict1[n - 3][-1] * dict1[n - 3][-2]
an_2 = int(math.sqrt(prod2 // prod1))
ans[n - 3] = an_2
for s in range(n):
	if s != n - 3:
		ans[s] = dict1[n - 3][s] // an_2
print(*ans)


inf = float('inf')
en = lambda x: list(enumerate(x))
import math
ii = lambda : int(input())
r = lambda : map(int, input().split())
rr = lambda : list(r())
n = ii()
arr = [rr() for _ in range(n)]
i = 0
a = arr[0][1]
b = arr[1][2]
c = arr[0][2]
ans = [int(math.sqrt(c * a // b))]
for i in range(1, n):
	ans += (arr[i][i - 1] // ans[-1],)
print(*ans)


n = int(input())
grid = []
for i in range(n):
	row = [int(p) for p in input().split()]
	grid.append(row)
(s, t) = (grid[0][1], grid[0][2])
bc = grid[1][2]
a = int((s * t / bc) ** 0.5)
print(a, end=' ')
for i in range(1, len(grid[0])):
	print(grid[i][0] // a, end=' ')
print('\n')


import sys
from math import sqrt
input = sys.stdin.readline

def main():
	n = int(input())
	a = [list(map(int, input().split())) for _ in range(n)]
	ans = [0] * n
	ans[0] = a[0][1] * a[0][2] // a[1][2]
	ans[0] = int(sqrt(ans[0]))
	for i in range(1, n):
		ans[i] = a[0][i] // ans[0]
	print(' '.join(map(str, ans)))
main()


import math
n = int(input())
a = []
for i in range(0, n):
	a.append(list(map(int, input().split())))
x = math.ceil(math.sqrt(a[0][1] * a[0][2] // a[1][2]))
y = int(x)
a[0][0] = y
for i in range(1, n):
	a[0][i] = a[0][i] // y
print(*a[0])


n = int(input())
a = [0] * 3
b = [0] * n
for i in range(3):
	a[i] = list(map(int, input().split()))
b[0] = int((a[0][1] * a[0][2] // a[1][2]) ** 0.5 + 1e-06)
for i in range(1, n):
	b[i] = a[0][i] // b[0]
print(' '.join(map(str, b)))


n = int(input())
grid = [list(map(int, input().split())) for _ in range(n)]
array = [0] * n
for i in range(1, n - 1):
	array[i] = int((grid[i - 1][i] * grid[i][i + 1] // grid[i - 1][i + 1]) ** 0.5)
array[0] = grid[0][1] // array[1]
array[n - 1] = grid[n - 2][n - 1] // array[n - 2]
print(*array)


import math
n = int(input())
l = [[0 for i in range(n)] for j in range(n)]
t = []
for i in range(n):
	a = list(map(int, input().split()))
	result = 0
	for j in range(i, n):
		if i == j:
			l[i][j] = a[i]
		else:
			l[i][j] = a[j]
			l[j][i] = a[j]
t.append(int(math.sqrt(l[0][1] * l[0][2] // l[1][2])))
print(t[0], end=' ')
for i in range(1, n):
	a = l[0][i] // t[0]
	print(a, end=' ')


import math
A = int(input())
B = []
for i in range(A):
	B += input().split(' ')
B = [int(i) for i in B]
C = int(math.sqrt(B[1] * B[2] / B[A + 2]))
ans = str(C)
for i in range(1, A):
	ans += ' ' + str(int(B[i] / C))
print(ans)


import math
n = int(input())
l = list()
for i in range(n):
	inp = input()
	inp = inp.split()
	for j in range(len(inp)):
		inp[j] = int(inp[j])
	l.append(inp)
ans = list()
for i in range(n):
	ans.append(math.sqrt(l[i][(i + 1) % n] * l[i][(i + 2) % n] / l[(i + 1) % n][(i + 2) % n]))
	print(int(ans[i]), end=' ')


n = int(input())
a = [[0 for i in range(n)] for i in range(n)]
for i in range(n):
	inp = list(map(int, input().split()))
	a[i] = inp
k = int(pow(a[0][1] * a[0][2] * a[1][2], 0.5))
l = [k // a[1][2]]
for i in range(1, n):
	l.append(a[0][i] // l[0])
for item in l:
	print(item, end=' ')


n = int(input())
a = []
for i in range(n):
	l = list(map(int, input().split()))
	a.append(l)
ans = []
sum = a[0][1] * a[0][2]
import math as m
x1 = m.sqrt(sum // a[1][2])
ans = [x1]
for i in range(1, n):
	ans.append(a[0][i] // x1)
for i in ans:
	print('%d' % i, end=' ')


n = int(input())
m = list()
a = [0] * n
for i in range(n):
	m.append(list(map(int, input().split())))
a[2] = int((m[2][0] * m[2][1] / m[1][0]) ** 0.5)
for i in range(n):
	if i != 2:
		a[i] = m[i][2] // a[2]
print(*a)


from sys import stdin
import math
n = int(stdin.readline())
m = [[] for _ in range(n)]
for i in range(n):
	m[i] = list(map(int, input().split()))
a = [0] * n
a[0] = int(math.sqrt(m[0][1] * m[0][2] // m[1][2]))
for e in range(1, n):
	a[e] = m[0][e] // a[0]
print(*a)


import math
n = int(input())
x = []
for i in range(n):
	x += [list(map(int, input().split()))]
j = 1
a = [0] * n
a[0] = int(math.sqrt(x[0][1] * x[0][2] / x[1][2]))
for i in range(1, n):
	a[i] = x[i][0] // a[0]
for i in a:
	print(i, end=' ')


from math import *
n = int(input())
m = []
for i in range(n):
	g = list(map(int, input().split()))
	m.append(g)
x = m[0][1]
y = m[0][2]
z = m[1][2]
a3 = int(sqrt(z * y // x))
a2 = a3 * x // y
a1 = x // a2
a = [a1, a2, a3]
for i in range(3, n):
	a.append(m[0][i] // a1)
for i in range(n):
	print(a[i], end=' ')


import math
n = int(input())
a = []
b = []
d = []
for i in range(n):
	a = [int(i) for i in input().split()]
	b.append(a)
c = b[0][1] / b[1][2]
c = math.ceil(c * b[0][2])
c = math.sqrt(c)
c = int(c)
d.append(c)
for i in range(1, n):
	d.append(b[i][0] // c)
print(*d)


import math

def main():
	n = int(input())
	a = [[] for _ in range(n)]
	for row in range(n):
		a[row] = list(map(int, input().split()))
	a1 = int(math.sqrt(a[0][1] * a[0][2] // a[1][2]))
	res = [a1] + [a[0][i] // a1 for i in range(1, n)]
	print(*res)
main()


from sys import stdin, stdout
from math import sqrt
from functools import reduce
input = stdin.readline
R = lambda : list(map(int, input().split()))
n = int(input())
a = []
for i in range(n):
	a.append(R())
p = int(sqrt(a[0][1] * a[0][2] // a[1][2]))
print(p, *[a[0][i] // p for i in range(1, n)])


N = int(input())
Numbers = []
for i in range(N):
	X = list(map(int, input().split()))
	if i < 2:
		Numbers.append(X)
First = int((Numbers[0][1] * (Numbers[0][2] / Numbers[1][2])) ** 0.5)
print(First, end=' ')
print(*[Numbers[0][i + 1] // First for i in range(N - 1)])


def sqrt(n):
	return int(n ** 0.5)

def checked_sqrt(n):
	s = sqrt(n)
	if s ** 2 != n:
		return s + 1 if (s + 1) ** 2 == n else s - 1
	return s
n = int(input())
s = [None] * n
T = [0] * 2
c = 2
for i in range(n):
	if c:
		t = list(map(int, input().split()))
		T[2 - c] = t
		c -= 1
	else:
		input()
a1 = checked_sqrt(T[0][1] * T[1][2] // T[0][2])
a0 = T[0][1] // a1
s[0] = a0
for i in range(1, n):
	s[i] = T[0][i] // a0
print(' '.join(map(str, s)))


n = int(input())
m = list(map(int, input().split()))[1:]
a = list(map(int, input().split()))[2]
for i in range(n - 2):
	input()
b = int((m[0] * m[1] / a) ** 0.5)
print(b, end=' ')
for el in m:
	print(el // b, end=' ')


n = int(input())
A = [list(map(int, input().split())) for _ in range(n)]
x = A[0][1]
y = A[1][2]
z = A[0][2]
p = (x * y * z) ** 0.5
a1 = p // y
a2 = p // z
a3 = p // x
ans = [round(a1), round(a2), round(a3)]
for i in range(3, n):
	ans.append(round(A[0][i] // a1))
print(' '.join(list(map(str, ans))))


import math
n = int(input())
a = [list(map(int, input().split())) for i in range(n)]
f = [0] * n
f[0] = int(math.sqrt(a[0][1] * a[0][2] / a[1][2]))
for i in range(1, n):
	f[i] = int(a[0][i] / f[0])
print(*f)


__author__ = 'Esfandiar'
from math import ceil, sqrt
n = int(input())
a = list()
res = [0] * n
for i in range(n):
	a.append(list(map(int, input().split())))
a1 = int(sqrt(a[0][1] * a[0][2] // a[1][2]))
res[0] = a1
for i in range(1, n):
	res[i] = a[0][i] // a1
print(*res)


from math import sqrt
n = int(input())
matrix = []
for i in range(n):
	matrix.append(list(map(int, input().split())))
a0 = int(sqrt(matrix[0][1] * matrix[0][2] / matrix[1][2]))
print(a0, end=' ')
for i in range(1, n):
	print(int(matrix[0][i] / a0), end=' ')
print('')


from sys import stdin, stdout
from math import sqrt
n = int(stdin.readline())
a = []
for i in range(n):
	a.append(list(map(int, stdin.readline().split())))
for i in range(n):
	if i > 0 and i < n - 1:
		stdout.write('%d ' % int(sqrt(a[i - 1][i] * a[i][i + 1] / a[i - 1][i + 1])))
	elif i == 0:
		stdout.write('%d ' % int(sqrt(a[n - 1][i] * a[i][i + 1] / a[n - 1][i + 1])))
	else:
		stdout.write('%d ' % int(sqrt(a[i - 1][i] * a[i][0] / a[i - 1][0])))


n = int(input())
table = [list(map(int, input().split())) for i in range(n)]
for i in range(n):
	num = table[i][(i + 1) % n]
	num2 = table[i][(i + 2) % n]
	num3 = table[(i + 2) % n][(i + 1) % n]
	print(int((num * num2 / num3) ** 0.5), end=' ')


import math

def MatrixToString(matrix):
	result = ''
	for i in matrix:
		result = result + str(i) + ' '
		result = result + '\n'
	return result
sizeOfTable = int(input())
listMultiplication = []
for row in range(sizeOfTable):
	listMultiplication.append(list(map(int, input().split())))
headers = []
firstPositionResult = math.sqrt(listMultiplication[0][1] * listMultiplication[0][2] / listMultiplication[1][2])
headers.append(int(firstPositionResult))
for i in range(1, sizeOfTable):
	headers.append(int(listMultiplication[0][i] / firstPositionResult))
print(' '.join(map(str, headers)))


input()
(a, b) = [[*map(int, input().split())] for _ in (0, 0)]
x = int((a[1] * a[2] / b[2]) ** 0.5)
print(x, *(y // x for y in a[1:]))


from math import sqrt
n = int(input())
a = [[0] * n for _ in range(n)]
for i in range(n):
	a[i] = [int(j) for j in input().strip().split(' ')]
a1 = int(sqrt(a[0][1] * a[0][2] / a[1][2]))
sol = []
sol.append(a1)
for i in range(1, n):
	sol.append(int(a[0][i] / a1))
for i in sol:
	print(i, end=' ')


from math import *
n = int(input())
m = []
for i in range(n):
	m.append([])
	p = input().split(' ')
	for j in range(n):
		m[i].append(int(p[j]))
b = int(sqrt(m[0][1] * m[1][2] * m[2][0])) // m[1][2]
print(b, end=' ')
for i in range(1, n):
	print(m[0][i] // b, end=' ')


n = int(input())
mat = []
for _ in range(n):
	mat.append(list(map(int, input().split())))
m = n // 2
mid = mat[m][m - 1] * mat[m + 1][m] / mat[m - 1][m + 1]
mid = mid ** 0.5
mylist = []
for i in range(n):
	if i == m:
		mylist.append(int(mid))
	else:
		mylist.append(int(mat[i][m] / int(mid)))
print(*mylist)


from math import sqrt
n = int(input())
a = [[0] * n] * n
for i in range(n):
	a[i] = list(map(int, input().split()))
for i in range(n):
	if i == 0:
		print(int(sqrt(a[0][1] * a[0][2] // a[1][2])), end=' ')
	elif i == n - 1:
		print(int(sqrt(a[n - 1][n - 2] * a[n - 1][n - 3] // a[n - 2][n - 3])), end=' ')
	else:
		print(int(sqrt(a[i][i - 1] * a[i][i + 1] // a[i - 1][i + 1])), end=' ')


n = int(input())
l = []
v = []
for i in range(0, n):
	v = list(map(int, input().split()))
	l.append(v)
a = (l[0][1] * l[1][2] / l[0][2]) ** 0.5
c = int(a)
q = []
for i in range(0, n):
	if i == 1:
		continue
	else:
		x = int(l[1][i] / c)
		q.append(x)
x = [c]
v = q[0:1] + x + q[1:]
for i in v:
	print(i, end=' ')


from sys import stdin
import math
n = int(stdin.readline())
M = []
for i in range(n):
	M.append(list(map(int, stdin.readline().rstrip().split())))
A = []
for i in range(n - 2):
	k1 = M[i][i + 1]
	k2 = M[i + 1][i + 2]
	k3 = M[i][i + 2]
	a1 = int(math.sqrt(k1 * k3 // k2))
	A.append(a1)
	if i == n - 3:
		a2 = int(math.sqrt(k1 * k2 // k3))
		a3 = int(math.sqrt(k2 * k3 // k1))
		A.append(a2)
		A.append(a3)
print(' '.join(map(str, A)))


n = int(input())
arr = [list(map(int, input().split())) for i in range(n)]
print(int((arr[0][1] * arr[0][2] // arr[1][2]) ** 0.5), end=' ')
for i in range(1, n - 1):
	print(int((arr[0][i] * arr[i][i + 1] // arr[0][i + 1]) ** 0.5), end=' ')
print(int((arr[-2][-1] * arr[-3][-1] // arr[-3][-2]) ** 0.5))


import math
n = int(input())
a = []
for i in range(n):
	a.append([int(s) for s in input().split()])
m = (a[0][1] * a[0][2] // a[1][2]) ** 0.5
m = int(m)
print(m, end=' ')
for i in range(1, n):
	print(a[0][i] // m, end=' ')


from math import sqrt
n = int(input())
m = []
for i in range(n):
	m.append([int(x) for x in input().split()])
a_b = m[0][1]
a_c = m[0][2]
b_c = m[1][2]
c = int(sqrt(b_c * a_c // a_b))
for i in range(0, n):
	if i == 2:
		print(c, end=' ')
	else:
		print(m[2][i] // c, end=' ')


import math
n = int(input())
m = []
for i in range(n):
	l = [int(x) for x in input().split()]
	m.append(l)
l = []
for i in range(0, n - 2):
	x = m[i][i + 1] * m[i][i + 2]
	x = x / m[i + 1][i + 2]
	x = math.sqrt(x)
	l.append(int(x))
l.append(int(m[0][n - 2] / l[0]))
l.append(int(m[0][n - 1] / l[0]))
ans = ''
for i in range(n):
	ans = ans + str(l[i]) + ' '
print(ans)


n = int(input())
arr = []
for i in range(n):
	arr.append(list(map(int, input().split())))
res = []
for i in range(n):
	a1 = (i + 1) % n
	a2 = (i + 2) % n
	res.append(int((arr[i][a1] * arr[i][a2] / arr[a1][a2]) ** 0.5))
for i in range(n):
	print(res[i], end=' ')
print()


import math
n = int(input())
matrix = []
for i in range(0, n):
	matrix.append([int(x) for x in input().split(' ')])
y_squar = matrix[0][1] * matrix[0][2] / matrix[2][1]
source = math.sqrt(y_squar)
result = []
for i in range(0, n):
	if i == 0:
		result.append(str(int(source)))
	else:
		result.append(str(int(matrix[0][i] / source)))
print(' '.join(result))


n = int(input())
d = []
for i in range(n):
	d.append([int(j) for j in input().split()])
x2 = d[1][0] * d[2][0] // d[2][1]
ans = [0] * n
ans[0] = int(x2 ** 0.5 + 0.5)
for i in range(1, n):
	ans[i] = d[0][i] // ans[0]
pl = [str(j) for j in ans]
print(' '.join(pl))


from math import sqrt
n = int(input())
l = []
for i in range(n):
	k = list(map(int, input().split()))
	l.append(k)
q = []
for i in range(n):
	k = 0
	r = []
	e = 1
	for j in range(n):
		if l[i][j] != 0:
			e *= l[i][j]
			k += 1
			r.append(j)
		if k == 2:
			break
	q.append(int(sqrt(e // l[r[0]][r[1]])))
print(*q)


from math import gcd, ceil, sqrt

def solve1(n):
	lo = []
	for i in range(1, int(sqrt(n)) + 1):
		if n % i == 0:
			z1 = n // i
			z2 = i
			lo.append(z1)
			lo.append(z2)
	return lo
n = int(input())
l = []
for i in range(n):
	la = list(map(int, input().split()))
	l.append(la)
ans = []
g = 0
final = []
for i in range(n):
	pr = 1
	g = 0
	for j in l[i]:
		g = gcd(j, g)
	ans.append(g)
z = ans[0]
ansi = -1
lo = solve1(z)
for i in lo:
	k1 = l[0][1] // i
	k2 = l[1][0] // k1
	if l[1][-1] // k1 == l[0][-1] // i:
		ansi = i
		break
final = [ansi]
for i in l[0][1:]:
	final.append(i // ansi)
print(*final)


import math
elem = int(input())
numbers = []
for x in range(elem):
	ar = []
	for t in input().split(' '):
		ar.append(int(t))
	numbers.append(ar)
ans = []
ans.append(int(math.sqrt(numbers[0][2] * numbers[0][1] / numbers[1][2])))
for x in numbers[0]:
	if x == 0:
		continue
	else:
		ans.append(int(x / ans[0]))
print(*ans)


n = int(input())
rows = []
for i in range(n):
	row = input().split()
	row = [int(i) for i in row]
	rows.append(row)
ar = rows
res = []
for i in range(n):
	col_1 = (i + 1) % n
	col_2 = (i + 2) % n
	ans = ar[i][col_1] / ar[i][col_2] * ar[col_1][col_2] + 0.5
	if i == n - 1:
		res.insert(0, ans ** 0.5)
		break
	res.append(ans ** 0.5)
print(' '.join([str(int(i)) for i in res]))


n = int(input())
d = []
c = []
for i in range(n):
	a = [int(x) for x in input().split()]
	d.append(a)
for i in range(n):
	if i < n - 2:
		x = d[i][i + 2] * d[i][i + 1] // d[i + 2][i + 1]
	elif n == 3 and i == 1:
		x = d[i - 1][i] * d[i + 1][i] // d[i + 1][i - 1]
	else:
		x = d[i][i - 2] * d[i - 1][i] // d[i - 2][i - 1]
	c.append(int(x ** 0.5))
for i in c:
	print(i, end=' ')


import math
n = int(input())
arr = []
for i in range(n):
	a = list(map(int, input().split()))
	arr.append(a)
a = []
for i in range(1, n - 1):
	a.append(int(math.sqrt(arr[i - 1][i] * arr[i - 1][i + 1] / arr[i][i + 1])))
i += 1
for j in range(2):
	a.append(arr[0][i - 1] // a[0])
	i += 1
print(*a)


n = int(input())
t = [list(map(int, input().split())) for i in range(n)]
b = int((t[0][1] * t[1][2] / t[0][2]) ** 0.5)
l = []
l.append(t[0][1] // b)
l.append(b)
for i in range(2, n):
	l.append(t[i][1] // b)
print(*l)


import math

def run():
	n = eval(input())
	M = []
	for _ in range(n):
		M.append(list(map(int, input().split())))
	result = []
	if n > 2:
		temp = int(math.ceil(math.sqrt(M[0][1] / (M[1][2] / M[0][2]))))
		result.append(temp)
		for i in range(1, n):
			temp = int(M[i - 1][i] / temp)
			result.append(temp)
	print(' '.join(map(str, result)))
run()


import sys
import math
while True:
	try:
		n = int(input())
	except EOFError:
		break
	mat = [[0 for x in range(n)] for y in range(n)]
	res = [0 for x in range(n)]
	for i in range(n):
		line = list(map(int, input().split()))
		for j in range(n):
			mat[i][j] = line[j]
	for i in range(n - 1):
		if i != 0 or i != n - 1:
			res[i] = mat[i][i - 1] * mat[i][i + 1] / mat[i - 1][i + 1]
			res[i] = math.sqrt(res[i])
	res[0] = math.sqrt(mat[0][1] * mat[1][0] / (res[1] * res[1]))
	res[n - 1] = math.sqrt(mat[n - 1][n - 2] * mat[n - 2][n - 1] / (res[n - 2] * res[n - 2]))
	for i in range(n):
		print(int(res[i]), end=' ')
	print('')
pass


n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
for i in range(n - 2):
	c = list(map(int, input().split()))
from math import sqrt
x = int(sqrt(a[1] * a[2] // b[2]))
print(x, end=' ')
for i in range(1, n):
	print(a[i] // x, end=' ')
print()


import sys, os, io
from sys import stdin
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
import math
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	return list(set(l))

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def countdig(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def prefix_sum(arr):
	r = [0] * (len(arr) + 1)
	for (i, el) in enumerate(arr):
		r[i + 1] = r[i] + el
	return r

def divideCeil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

def si():
	return input()

def ii():
	return int(input())

def li():
	return list(map(int, input().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
t = 1
for _ in range(t):
	n = ii()
	l = []
	for i in range(n):
		l.append(li())
	a = [0] * n
	y = int((l[0][2] * l[1][2] // l[0][1]) ** 0.5)
	x = int(l[0][2] / y)
	print(x, end=' ')
	for i in range(1, n):
		print(l[0][i] // x, end=' ')
	print()


n = int(input())
arr = [list(map(int, input().split())) for i in range(n)]
ans = [0] * n
ans[0] = int(pow(arr[0][1] * arr[0][2] // arr[1][2], 0.5))
for i in range(1, n):
	ans[i] = arr[0][i] // ans[0]
print(*ans)


from math import sqrt
n = int(input())
matrix = [[0] * n for r in range(n)]
for r in range(n):
	matrix[r] = list(map(int, input().split()))
c = sqrt(matrix[1][2] / (matrix[0][1] / matrix[0][2]))
b = matrix[0][1] / matrix[0][2] * c
a = matrix[0][1] / b
print(int(a), end=' ')
for i in matrix[0][1:]:
	print(int(i / a), end=' ')


import math
n = int(input())
table = []
for i in range(n):
	table.append([int(x) for x in input().split()])
for i in range(n):
	if i + 2 >= n:
		print(round(math.sqrt(table[i][i - 1] / table[i - 1][i - 2] * table[i][i - 2])), end='')
	else:
		print(round(math.sqrt(table[i][i + 1] / table[i + 1][i + 2] * table[i][i + 2])), end='')
	if i != n - 1:
		print(' ', end='')
	else:
		print('\n', end='')


n = int(input())
A = []
for i in range(n):
	a = input().split()
	for j in range(n):
		a[j] = int(a[j])
	A.append(a)
a = A[0][1] * A[0][2] // A[1][2]
b = int(a ** 0.5)
print(b, end=' ')
for i in range(n - 1):
	print(A[0][i + 1] // b, end=' ')


n = int(input())
a = [0 for x in range(n)]
m = [[int(y) for y in input().split()] for x in range(n)]
for i in range(2, n):
	a[i] = (m[i - 2][i] * m[i][i - 1] / m[i - 1][i - 2]) ** 0.5
a[0] = m[0][2] / a[2]
a[1] = m[1][2] / a[2]
ans = ''
for x in a:
	ans += str(int(x)) + ' '
print(ans)


n = input()
a = [*map(int, input().split())]
a[0] = a[1] * a[2] // int(input().split()[2])
for i in a:
	print(int(i // a[0] ** 0.5), end=' ')


from math import sqrt
n = int(input())
lst = list(map(int, input().split()))[1:]
a = list(map(int, input().split()))[2]
for i in range(n - 2):
	input()
b = int(sqrt(lst[0] * lst[1] / a))
print(b, end=' ')
for elem in lst:
	print(elem // b, end=' ')


import math
n = int(input())
mat = []
for i in range(n):
	arr = input()
	l = list(map(int, arr.split(' ')))
	mat.append(l)
for i in range(n):
	j = (i + 1) % n
	k = (j + 1) % n
	x = math.sqrt(mat[i][j] * mat[i][k] / mat[j][k])
	print(int(x), end=' ')


import math
n = input()
n = int(n)
line1 = input()
line2 = input()
numbers1 = line1.split(' ')
numbers2 = line2.split(' ')
a = math.sqrt(int(numbers1[1]) * int(numbers1[2]) / int(numbers2[2]))
res = '' + str(int(a))
i = 1
while i < n:
	res += ' ' + str(int(int(numbers1[i]) / a))
	i += 1
print(res)


import math
a = []
t = int(input())
for i in range(t):
	if i == 0:
		l = list(map(int, input().split()))
	elif i == 1:
		k = list(map(int, input().split()))
	else:
		ll = list(map(int, input().split()))
k = int(math.sqrt(int(l[1] * l[2] / k[2])))
a.append(str(k))
for j in range(1, t):
	a.append(str(int(l[j] / k)))
print(' '.join(a))


a = [[int(s) for s in input().split()] for i in range(int(input()))]
b = [0 for i in range(len(a))]
for i in range(2, len(b)):
	b[i - 1] = int((a[i - 2][i - 1] * a[i - 1][i] / a[i - 2][i]) ** 0.5)
b[0] = a[0][1] // b[1]
b[-1] = a[0][-1] // b[0]
for i in range(len(b)):
	print(b[i], end=' ')
print()


from math import sqrt
n = int(input())
l0 = [int(n) for n in input().split()]
l1 = [int(n) for n in input().split()]
v = int(sqrt(l0[1] * l0[2] * l1[2]))
a0 = v // l1[2]
a1 = l1[0] // a0
print(a0, a1, end=' ')
for i in range(2, n):
	na = int(input().split()[0])
	print(na // a0, end=' ')


n = int(input())
k = [list(map(int, input().split())) for _ in range(n)]
for i in range(n):
	if i == n - 2:
		print(int((k[i][i - 1] * k[i][i + 1] / k[i - 1][i + 1]) ** (1 / 2)))
	elif i == n - 1:
		print(int((k[i][i - 1] * k[i][i - 2] / k[i - 1][i - 2]) ** (1 / 2)))
	else:
		print(int((k[i][i + 1] * k[i][i + 2] / k[i + 1][i + 2]) ** (1 / 2)))


from math import sqrt
n = int(input())
a = []
for i in range(n):
	m = [int(i) for i in input().split()]
	a.append(m)
k = a[1][2] / a[0][2]
x = round(sqrt(a[1][0] / k))
print(x, end=' ')
for i in range(1, n):
	print(round(a[i][0] / x), end=' ')


import sys
from operator import itemgetter
from fractions import gcd
from math import ceil, floor, sqrt
from copy import deepcopy
from collections import Counter, deque
import heapq
from functools import reduce
sys.setrecursionlimit(200000)
input = sys.stdin.readline

def ii():
	return int(input())

def mi():
	return map(int, input().rstrip().split())

def lmi():
	return list(map(int, input().rstrip().split()))

def fi():
	return float(input())

def mfi():
	return map(float, input().rstrip().split())

def lmfi():
	return list(map(float, input().rstrip().split()))

def li():
	return list(input().rstrip())

def debug(*args, sep=' ', end='\n'):
	print('debug:', *args, file=sys.stderr, sep=sep, end=end) if not __debug__ else None

def exit(*arg):
	print(*arg)
	sys.exit()

def main():
	N = ii()
	A = [[0 for j in range(N)] for i in range(N)]
	for i in range(N):
		A[i] = lmi()
	a = 0
	for i in A[0]:
		a = gcd(a, i)
	g = []
	i = 1
	while i * i <= a:
		if a % i == 0:
			g.append(a // i)
			g.append(i)
		i += 1
	g.sort()
	g.reverse()

	def ok(idx, l, A):
		for i in range(N):
			if i != idx:
				if l[i] * l[idx] != A[i][idx]:
					return False
		return True
	for x in g:
		flag = True
		ans = [0] + [A[0][i] // x for i in range(1, N)]
		ans[0] = A[1][0] // (A[1][2] // ans[2])
		for i in range(N):
			if not ok(i, ans, A):
				flag = False
				break
		if flag:
			exit(*ans)
	return
main()


from math import sqrt
n = int(input())
mp = []
for i in range(n):
	mp.append(list(map(int, input().split())))
a1 = int(sqrt(mp[0][1] * mp[0][2] // mp[1][2]))
for i in range(n):
	if i == 0:
		print(a1, end=' ')
	else:
		print(mp[i][0] // a1, end=' ')


n = int(input())
l = []
for x in range(n):
	l.append([int(i) for i in input().split()])
god = int((l[0][1] * l[0][2] / l[1][2]) ** 0.5)
a = []
a.append(god)
for x in range(1, n):
	a.append(int((l[0][x] * l[x][0] / god ** 2) ** 0.5))
for x in a:
	print(x, end=' ')


n = int(input())
arr = [list(map(int, input().split())) for _ in range(n)]
c = arr[1][2] / arr[0][2]
a = round((arr[0][1] / c) ** 0.5)
res = [a]
for i in range(1, n):
	res.append(arr[i][0] // a)
print(*res)


def fastio():
	import sys
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
MOD = 10 ** 9 + 7
INF = 10 ** 20
I = lambda : list(map(int, input().split()))
from collections import defaultdict as dd
from math import gcd
(n,) = I()
a = []
for i in range(n):
	a.append(I())
ab = a[0][1]
ac = a[0][2]
bc = a[1][2]
ans = int((ab * ac // bc) ** 0.5)
print(*[ans] + [i // ans for i in a[0][1:]])


import math
n = int(input())
matrix = []
for i in range(n):
	l = []
	s = input().split(' ')
	for j in s:
		l.append(int(j))
	matrix.append(l)
l = matrix[0]
g = int(math.sqrt(matrix[0][1] * matrix[0][2] / matrix[1][2]))
arr = [g]
for i in range(1, len(l)):
	arr.append(int(l[i] / g))
for i in range(len(arr)):
	if i == len(arr) - 1:
		print(arr[i])
	else:
		print(arr[i], end=' ')


import math
n = int(input())
l1 = []
l2 = []
l3 = []
l4 = []
for a in range(n):
	x = input()
	if a == 0:
		l1 = x.split()
		for a in range(len(l1)):
			l1[a] = int(l1[a])
		l1 = l1[1:]
	l3 = x.split()
	if x != 0 and x != n - 1:
		l2.append(int(l3[-1]))
l = int(math.sqrt(l2[0] * l2[1] / l1[0]))
for b in range(len(l2) - 1):
	l4.append(int(l2[b] / l))
l4.append(l)
for c in l4:
	print(c, end=' ')


import math
n = int(input())
a = []
for itr in range(n):
	a.append(list(map(int, input().split())))
g = []
g.append(int(math.sqrt(a[0][1] * a[0][2] / a[1][2])))
for i in range(1, n):
	g.append(a[0][i] // g[0])
for i in g:
	print(i, end=' ')


import math
n = int(input())
a = []
for i in range(n):
	a.append(list(map(int, input().split())))
ans = []
for i in range(n - 2):
	ans.append(str(int(math.sqrt(a[i][i + 1] * a[i][i + 2] // a[i + 1][i + 2]))))
ans.append(str(a[0][n - 2] // int(ans[0])))
ans.append(str(a[0][n - 1] // int(ans[0])))
print(' '.join(ans))


n = int(input())
l = []
q = []
w = []
for i in range(0, n):
	p = input().rstrip().split(' ')
	l.append(p)
	x = list(p)
	x.sort(key=int)
	q.append(int(x[1]))
A = min(q)
V = q.index(A)
for i in range(1, A + 1):
	w = [0] * n
	w[V] = i
	for j in range(0, len(l[V])):
		if j != V and int(l[V][j]) != 0:
			if int(l[V][j]) % i != 0:
				break
			else:
				w[j] = int(l[V][j]) // w[V]
	if w.count(0) >= 1:
		continue
	else:
		D = []
		G = 0
		for j in range(0, len(l)):
			for k in range(0, len(l[j])):
				if j == k:
					continue
				elif w[j] * w[k] != int(l[j][k]):
					G = 1
					break
			if G == 1:
				break
		else:
			T = w
			break
print(*T)


from math import sqrt
n = int(input())
t = [list(map(int, input().split())) for _ in range(n)]
x = int(sqrt(t[0][1] * t[0][2] // t[1][2]))
l = [x] + [i // x for i in t[0][1:]]
print(*l)


import math
N = int(input())
M = []
for _ in range(N):
	M.append(list(map(int, input().split())))
M[0][0] = int(math.sqrt(M[0][1] * M[0][2] / M[1][2]))
for n in range(1, N):
	M[n][n] = int(M[n - 1][n] / M[n - 1][n - 1])
ans = []
for n in range(N):
	ans.append(str(M[n][n]))
print(' '.join(ans))


import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
from heapq import heappush as hpush
from heapq import heappop as hpop
mod = 10 ** 9 + 7

def ri(flag=0):
	if flag == 0:
		return [int(i) for i in sys.stdin.readline().split()]
	else:
		return int(sys.stdin.readline())

def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)
n = ri(1)
mat = []
for i in range(n):
	mat.append(ri())
a1 = mat[0][1] * mat[0][2] // mat[1][2]
a1 = int(a1 ** 0.5)
ans = [a1]
for i in range(1, n):
	ans.append(mat[0][i] // a1)
print(*ans)


import os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
n = int(input())
m = []
for i in range(n):
	m.append(list(map(int, input().split())))
x = m[1][2]
y = m[0][2] / m[0][1]
a3 = int((x * y) ** 0.5)
a2 = x // a3
a1 = m[0][1] // a2
a = [a1, a2, a3]
for i in range(3, n):
	a.append(m[0][i] // a1)
print(*a)


import math
n = int(input())
num = [[int(x) for x in input().split()] for i in range(0, n)]
ans = [0] * n
ans[0] = math.sqrt(num[0][1] * num[0][2] / num[1][2])
for i in range(1, n):
	ans[i] = num[0][i] / ans[0]
for i in range(0, n):
	print(int(ans[i]), end=' ')


import math
n = int(input())
ans = []
for i in range(0, n):
	a = [int(i) for i in input().split()]
	ans.append(a)
a = []
s = 1
t = 2
for i in range(0, n):
	if s == n:
		s = 0
	if t == n:
		t = 0
	prod = ans[i][s] * ans[i][t] // ans[s][t]
	prod1 = int(math.pow(prod, 0.5))
	a.append(prod1)
	s += 1
	t += 1
print(*a, sep=' ')


import sys
input = sys.stdin.readline

def getInt():
	return int(input())

def getVars():
	return map(int, input().split())

def getList():
	return list(map(int, input().split()))

def getStr():
	return input().strip()

def addDictList(d, key, val):
	if key not in d:
		d[key] = []
	d[key].append(val)

def addDictInt(d, key, val):
	if key not in d:
		d[key] = 0
	d[key] = val

def addDictCount(d, key):
	if key not in d:
		d[key] = 0
	d[key] += 1

def addDictSum(d, key, val):
	if key not in d:
		d[key] = 0
	d[key] += val

def NOD(a, b):
	while a != 0 and b != 0:
		if a > b:
			a %= b
		else:
			b %= a
	return a + b
n = getInt()
res = []
a1 = getList()
a2 = getList()
res.append(int((a1[2] * a1[1] / a2[2]) ** 0.5))
for i in range(1, n):
	res.append(int(a1[i] / res[0]))
print(*res)


import math
n = int(input())
lst = []
a = []
for i in range(n):
	d = input()
	d = d.split(' ')
	d = [int(x) for x in d]
	lst.append(d)
	a.append(0)
a[0] = math.sqrt(lst[0][1] * lst[0][2] / lst[1][2])
for i in range(1, n):
	a[i] = lst[0][i] / a[0]
for i in range(n):
	a[i] = int(a[i])
print(*a)


import math
n = int(input())
l = []
for _ in range(n):
	m = list(map(int, input().split()))
	l.append(m)
a = l[0][1]
b = l[0][2]
c = l[1][2]
k = []
e = math.sqrt(a * b / c)
k.append(int(e))
for i in range(1, n):
	k.append(l[0][i] // int(e))
print(*k)


from math import sqrt
n = int(input())
a = []
for _ in range(n):
	a.append(list(map(int, input().split())))
a[1][1] = int(sqrt(a[0][1] * a[1][2] / a[0][2]))
for i in range(n):
	if i == 1:
		print(a[i][i], end=' ')
		continue
	if i == 0:
		a[i][i] = a[i + 1][i] // a[i + 1][i + 1]
	else:
		a[i][i] = a[i - 1][i] // a[i - 1][i - 1]
	print(a[i][i], end=' ')


n = int(input())
m = []
for i in range(n):
	m.append([int(x) for x in input().split()])
import math

def find(n, m):
	res = []
	for i in range(n):
		if i == 0:
			res.append(math.sqrt(m[i][i + 1] * m[i][i + 2] // m[i + 1][i + 2]))
		elif i == n - 1:
			res.append(math.sqrt(m[i][i - 1] * m[i][i - 2] // m[i - 1][i - 2]))
		else:
			res.append(math.sqrt(m[i][i + 1] * m[i][i - 1] // m[i + 1][i - 1]))
	return ' '.join([str(int(x)) for x in res])
print(find(n, m))


from math import sqrt
n = int(input())
arr = [list(map(int, input().split())) for _ in range(n)]
kek = []
for i in range(n):
	lol = [0, 1] if i > 1 else [1, 2] if i == 0 else [0, 2]
	(a, b) = lol
	kek.append(int(sqrt(arr[i][a] * arr[i][b] // arr[a][b])))
print(' '.join(map(str, kek)))


from math import sqrt
number = int(input())
a = []
n = []
for i in range(number):
	line = list(map(int, input().split()))
	a.append(line)
	if i == number - 3:
		z = line[number - 2]
		y = line[number - 1]
	if i == number - 2:
		x = line[number - 1]
		an1 = sqrt(z * y / x)
		an = z / an1
		an2 = x / an
n.append(round(an2))
n.append(round(an))
n.append(round(an1))
bn = an1
j = number - 4
while j >= 0:
	z = a[j][j + 1]
	bn1 = z / bn
	n.append(round(bn1))
	bn = bn1
	j = j - 1
n = list(reversed(n))
print(' '.join((str(x) for x in n)))


N = int(input())
b = 0
c = 0
k = ''
for i in range(1, N + 1):
	s = input().split()
	if i > 1 and i < N:
		a = int(s[i])
	if i > 1 and i < N - 1:
		ans = int((b * c / a) ** (1 / 2))
		b = a
		c = int(s[i + 1])
		k = k + str(ans) + ' '
	elif i > 1 and i == N - 1:
		ans = int((b * c / a) ** (1 / 2))
		k = k + str(ans) + ' '
		k = k + str(int(b / ans)) + ' '
		k = k + str(int(c / ans))
	elif i == 1:
		b = int(s[i])
		c = int(s[i + 1])
print(k)


n = int(input())
l = []
temp = []
for i in range(n):
	temp = list(map(int, input().split()))
	l.append(temp)
	temp = []
for i in range(n):
	print(int((l[i][(i + 1) % n] * l[i][(i + 2) % n] // l[(i + 1) % n][(i + 2) % n]) ** 0.5), end=' ')


import math
n = int(input())
l = []
for i in range(n):
	l.append(list(map(int, input().split())))
a = l[0][1]
b = l[0][2]
c = l[1][2]
ans = []
k = a * b // c
ans.append(int(math.sqrt(k)))
k = a * c // b
ans.append(int(math.sqrt(k)))
k = c * b // a
ans.append(int(math.sqrt(k)))
for i in range(3, n):
	k = l[0][i] * l[1][i] // a
	ans.append(int(math.sqrt(k)))
print(*ans)


import math
n = int(input())
arr = []
for i in range(n):
	a = list(map(int, input().split()))
	arr.append(a)
a = []
for i in range(n):
	a.append(i)
a[0] = math.sqrt(arr[0][2] * arr[0][1] / arr[2][1])
for i in range(1, n):
	a[i] = arr[i][0] / a[0]
lis = []
for i in range(n):
	lis.append(str(int(a[i])))
k = ' '.join(lis)
print(k)


import math
n = int(input())
l = []
a1a2 = 0
a1a3 = 0
a2a3 = 0
for i in range(n):
	l1 = list(map(int, input().split()))
	if i == n - 1:
		break
	elif i == 0:
		a1a2 = l1[1]
		a1a3 = l1[2]
	elif i == 1:
		a2a3 = l1[2]
		l.append(round(math.sqrt(a1a2 / a2a3 * a1a3)))
		l.append(round(a1a2 / l[0]))
		l.append(round(a2a3 / l[1]))
	else:
		l.append(round(l1[i + 1] / l[len(l) - 1]))
print(*l)


import sys
from collections import defaultdict
from itertools import combinations
input = lambda : sys.stdin.readline().rstrip()
n = int(input())
arr = [list(map(int, input().split())) for i in range(n)]
ans = [0] * n
for i in range(n - 2):
	ans[i] = int((arr[i][i + 1] * arr[i][i + 2] // arr[i + 1][i + 2]) ** 0.5)
ans[n - 2] = arr[n - 2][0] // ans[0]
ans[n - 1] = arr[n - 1][0] // ans[0]
print(*ans)


import math

def solve(arr, n):
	a1 = int(math.sqrt(arr[0][1] * arr[0][2] // arr[1][2]))
	ans = [a1]
	for i in arr[0][1:]:
		ans.append(i // a1)
	for i in ans:
		print(i, end=' ')
test = 1
for t in range(0, test):
	n = int(input())
	(rows, cols) = (n, n)
	arr = [[int(i) for i in input().split()] for j in range(rows)]
	solve(arr, n)


n = int(input())
l = []
arr = []
for i in range(n):
	a = list(map(int, input().split()))
	l.append(a)
	arr.append(0)
a1 = l[2][0] * l[0][1] / l[1][2]
arr[0] = int(a1 ** 0.5)
for i in range(1, n):
	arr[i] = l[0][i] // arr[0]
for i in range(n):
	print(arr[i], end=' ')


import math
n = int(input())
arr = [list(map(int, input().split())) for x in range(n)]
a00 = math.sqrt(arr[0][1] * arr[0][2] / arr[1][2])
print(int(a00), end=' ')
for i in range(1, n):
	print(int(arr[i][0] // a00), end=' ')


from math import sqrt

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
n = int(input())
lis = []
for _ in range(n):
	lis.append(list(map(int, input().split())))
res = []
for i in range(n):
	res.append([])
	if lis[i][0] == 0:
		k = 1
	else:
		k = 0
	g = lis[i][k]
	for j in range(k, n):
		if lis[i][j] != 0:
			g = gcd(g, lis[i][j])
	for j in range(n):
		res[i].append(lis[i][j] // g)
res.sort(key=lambda x: -(x[0] + x[1] + x[2]))
r = res[0][:]
k1 = r.index(0)
if k1 == 0:
	k2 = k1 + 1
else:
	k2 = k1 - 1
for i in res:
	if i[k1] != 0 and i[k2] != 0:
		break
r[k1] = r[k2] * i[k1] / i[k2]
x = lis[1][0] // (r[1] * r[0])
x = int(sqrt(x))
for i in range(n):
	r[i] *= x
	r[i] = int(r[i])
print(*r)


n = int(input())
dp = []
for i in range(0, n):
	a = list(map(int, input().split()))
	dp.append(a)
prod = dp[0][1]
a13 = dp[0][2]
a23 = dp[1][2]
a1 = (a13 * prod // a23) ** 0.5
a1 = int(a1)
print(a1, end=' ')
for i in range(1, n):
	ans = dp[0][i] // a1
	print(ans, end=' ')


from math import sqrt
n = int(input())
a = [[int(s) for s in input().split()] for i in range(n)]
b = []
k = 1
w = 0
k = a[0][2] * a[0][1] / a[1][2]
k = round(sqrt(k))
b = []
b.append(k)
for i in range(1, n):
	b.append(a[0][i] // k)
print(*b)


import sys
import math
import collections
import operator as op
from collections import deque
from math import gcd, inf, sqrt, pi, cos, sin, ceil, log2, floor, log
from bisect import bisect_right, bisect_left, bisect
from itertools import permutations
from functools import reduce
from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(2 ** 20)

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom

def prime_factors(n):
	i = 2
	factors = []
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.append(i)
	if n > 1:
		factors.append(n)
	return list(factors)

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def find_gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
MOD = 1000000007
PMOD = 998244353
LOGN = 30
alp = 'abcdefghijklmnopqrstuvwxyz'
N = int(100000.0)
T = 1
for _ in range(T):
	n = int(stdin.readline())
	a = []
	for i in range(n):
		r = list(map(int, stdin.readline().rstrip().split()))
		a.append(r)
	a0 = int(sqrt(a[0][1] * a[0][2] // a[1][2]))
	ans = [a0]
	for i in range(1, n):
		x = a[i][0] // a0
		ans.append(x)
	print(*ans)


import math
n = int(input())
arr = []
for i in range(0, n):
	x = input().split()
	arr.append(x)
x = math.sqrt(int(arr[0][1]) * int(arr[0][2]) / int(arr[1][2]))
print(int(x), end=' ')
x = math.sqrt(int(arr[1][0]) * int(arr[1][2]) / int(arr[0][2]))
print(int(x), end=' ')
for i in range(2, n):
	x = math.sqrt(int(arr[i][1]) * int(arr[i][0]) / int(arr[1][0]))
	print(int(x), end=' ')


n = int(input())
M = [[]] * n
for i in range(n):
	M[i] = list(map(int, input().split()))
rs = []
tl = []
for i in range(2, n):
	tl.append(float(M[0][1]) / M[0][i])
for i in range(2, n):
	rs.append((M[i][1] / tl[i - 2]) ** 0.5)
a1 = int(round(rs[0] * tl[0]))
a0 = int(round(M[0][1] / a1))
print(a0, a1, end=' ')
for i in rs:
	print(int(round(i)), end=' ')


import math
n = int(input())
s = []
for i in range(n):
	s.append([int(x) for x in input().split()])
a = []
a.append(int(math.sqrt(s[0][1] * s[0][2] // s[1][2])))
for i in range(1, n):
	a.append(s[0][i] // a[0])
print(' '.join((str(x) for x in a)))


import sys, os, io

def rs():
	return sys.stdin.readline().rstrip()

def ri():
	return int(sys.stdin.readline())

def ria():
	return list(map(int, sys.stdin.readline().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math, datetime, functools, itertools
from collections import deque, defaultdict, OrderedDict
import collections

def main():
	starttime = datetime.datetime.now()
	if os.path.exists('input.txt'):
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	for _ in range(1):
		n = ri()
		mat = []
		for i in range(n):
			mat.append([0] * n)
		for i in range(n):
			mat[i] = ria()
		x = mat[0][1]
		y = mat[2][1]
		z = mat[0][2]
		a = int(math.sqrt(x * z // y))
		ans = [a]
		for i in range(1, n):
			ans.append(mat[0][i] // a)
		print(*ans)
	endtime = datetime.datetime.now()
	time = (endtime - starttime).total_seconds() * 1000
	if os.path.exists('input.txt'):
		print('Time:', time, 'ms')

class FastReader(io.IOBase):
	newlines = 0

	def __init__(self, fd, chunk_size=1024 * 8):
		self._fd = fd
		self._chunk_size = chunk_size
		self.buffer = io.BytesIO()

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self, size=-1):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

class FastWriter(io.IOBase):

	def __init__(self, fd):
		self._fd = fd
		self.buffer = io.BytesIO()
		self.write = self.buffer.write

	def flush(self):
		os.write(self._fd, self.buffer.getvalue())
		(self.buffer.truncate(0), self.buffer.seek(0))

class FastStdin(io.IOBase):

	def __init__(self, fd=0):
		self.buffer = FastReader(fd)
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

class FastStdout(io.IOBase):

	def __init__(self, fd=1):
		self.buffer = FastWriter(fd)
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.flush = self.buffer.flush
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()


n = int(input())
a = []
for i in range(n):
	a.append(list(map(int, input().split())))
a
import math
k = a[0][2] * a[1][0] // a[1][2]
k = int(math.sqrt(k))
l = []
l.append(k)
for i in a[0]:
	if i == 0:
		continue
	l.append(i // k)
for i in l:
	print(i, end=' ')


import math
n = int(input())
a = list()
for i in range(n):
	a.append(list(map(int, input().split())))
b = list()
for i in range(n):
	(x, y) = ((i + 1) % n, (i + 2) % n)
	b.append(math.sqrt(a[i][x] * a[i][y] // a[x][y]))
for el in b:
	print(int(el), end=' ')


n = int(input())
matrix = []
a = [0] * n
for i in range(n):
	matrix.append(list(map(int, input().split())))
if n == 3:
	for i in range(n):
		if i + 2 < n:
			a[i] = int((matrix[i][i + 1] * matrix[i][i + 2] / matrix[i + 1][i + 2]) ** 0.5)
		elif i + 2 == n:
			a[i] = int((matrix[i][i - 1] * matrix[i][i + 1] / matrix[i - 1][i + 1]) ** 0.5)
		else:
			a[i] = int((matrix[i][i - 1] * matrix[i][i - 2] / matrix[i - 1][i - 2]) ** 0.5)
else:
	for i in range(n):
		if i + 2 < n:
			a[i] = int((matrix[i][i + 1] * matrix[i][i + 2] / matrix[i + 1][i + 2]) ** 0.5)
		else:
			a[i] = int((matrix[i][i - 1] * matrix[i][i - 2] / matrix[i - 1][i - 2]) ** 0.5)
for i in range(n):
	print(a[i], end=' ')


from math import sqrt
n = int(input())
eps = 1e-08
a = [list(map(int, input().split())) for _ in range(n)]
ans = [0] * n
ans[1] = int(sqrt(a[0][1] * a[1][2] // a[0][2]) + eps)
ans[0] = a[0][1] // ans[1]
for i in range(2, n):
	ans[i] = a[0][i] // ans[0]
print(*ans)


from math import sqrt
n = int(input().strip())
table = list()
for _ in range(n):
	line = [int(x) for x in input().strip().split(' ')]
	table.append(line)
a = [0] * n
for i in range(n - 2):
	a[i] = int(sqrt(table[i][i + 1] * table[i][i + 2] / table[i + 1][i + 2]))
a[n - 2] = int(table[n - 3][n - 2] / a[n - 3])
a[n - 1] = int(table[n - 2][n - 1] / a[n - 2])
for item in a:
	print(item, end=' ')
print()


n = int(input())
mat = []
for i in range(n):
	mat.append([int(i) for i in input().split()])
a4a5 = mat[n - 2][n - 1]
a3a4 = mat[n - 3][n - 2]
a3a5 = mat[n - 3][n - 1]
ans = [0] * n
ans[n - 3] = a3a4 * a3a5 // a4a5
x = ans[n - 3]
ans[n - 3] = int(x ** 0.5)
for i in range(n):
	if i != n - 3:
		ans[i] = mat[n - 3][i] // ans[n - 3]
print(*ans)


n = int(input())
a = [0, 0, 0, 0]
for i in range(1, 4):
	a[i] = list(map(int, input().split()))
	a[i] = [0] + a[i]
for i in range(1, n + 1):
	if i == 1:
		print(int(0.01 + (a[1][2] * a[1][3] / a[2][3]) ** 0.5), end=' ')
	elif i == 2:
		print(int(0.01 + (a[1][2] * a[2][3] / a[1][3]) ** 0.5), end=' ')
	else:
		print(int(0.01 + (a[1][i] * a[2][i] / a[1][2]) ** 0.5), end=' ')


import math
n = int(input())
m = []
for i in range(n):
	k = []
	s = input()
	k = s.split(' ')
	m.append(k)
A = []
z = int(m[0][1]) * int(m[0][2]) // int(m[1][2])
z = int(math.sqrt(z))
A.append(z)
for i in range(n - 1):
	q = int(m[0][i + 1]) // int(A[0])
	A.append(q)
print(*A)


import sys
input = sys.stdin.readline
n = int(input())
matrix = [list(map(int, input().split())) for i in range(n)]
matrix[0][0] = matrix[0][1] * matrix[0][2] / matrix[1][2]
for i in range(n):
	print(int(matrix[i][0] / matrix[0][0] ** 0.5), end=' ')


input()
(f_c, s_c) = [list(map(int, input().split())) for _ in range(2)]
x = int((f_c[1] * f_c[2] / s_c[2]) ** 0.5)
print(x, *(y // x for y in f_c[1:]))


n = int(input())
a = [list(map(int, input().split())) for i in range(n)]
n2 = [int((a[i][i + 1] * a[i + 1][i + 2] / a[i][i + 2]) ** 0.5) for i in range(n - 2)]
n2 = n2 + [a[n - 2][n - 1] // n2[n - 3]]
print(sum(a[0]) // sum(n2), *n2)


n = int(input())
a = [[int(i) for i in input().split()] for j in range(n)]
ans = []
a[0][0] = a[2][0] * a[0][1] // a[2][1]
ans.append(int(a[0][0] ** 0.5))
for i in range(1, n):
	a[i][i] = a[i - 1][i] * a[i][i - 1] // a[i - 1][i - 1]
	ans.append(int(a[i][i] ** 0.5))
print(*ans)


from heapq import heappush, heappop
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations
import sys
import bisect
import string

def I():
	return int(input())

def MI():
	return map(int, input().split())

def LI():
	return [int(i) for i in input().split()]

def LI_():
	return [int(i) - 1 for i in input().split()]

def StoI():
	return [ord(i) - 97 for i in input()]

def show(*inp, end='\n'):
	if show_flg:
		print(*inp, end=end)
YN = ['Yes', 'No']
mo = 10 ** 9 + 7
input = sys.stdin.readline
show_flg = False
n = I()
m = []
for _ in range(n):
	m.append(LI())
show(m)
a0 = m[0][1] * (m[0][2] / m[1][2])
show(m[0][1] * m[0][2] / m[1][2], m[0][2], m[1][2])
a = [int(a0 ** 0.5 + 1e-05)]
show(a)
for i in range(1, n):
	a.append(m[i - 1][i] // a[-1])
	show(m[i - 1][i], a[-1])
print(*a)


import math
n = int(input())
arr = []
for _ in range(n):
	arr.append(list(map(int, input().split())))
s = int(math.sqrt(arr[0][1] * arr[0][2] // arr[1][2]))
print(s, end=' ')
for i in range(1, n):
	print(arr[0][i] // s, end=' ')


import math
n = int(input())
mat = []
for i in range(n):
	arr = list(map(int, input().split()))
	mat.append(arr)
ans = [0 for i in range(n)]
for i in range(n):
	for j in range(n):
		if j + 1 < n and i != j and (i != j + 1):
			temp = int(math.sqrt(mat[i][j] * mat[i][j + 1] / mat[j][j + 1]))
			ans[i] = temp
for i in range(n):
	if ans[i] == 0:
		if i + 1 < n:
			ans[i] = int(mat[i][i + 1] / ans[i + 1])
		if i - 1 >= 0:
			ans[i] = int(mat[i][i - 1] / ans[i - 1])
for a in ans:
	print(a, end=' ')


n = int(input())
arr = []
for i in range(n):
	l1 = list(map(int, input().split()))
	arr.append(l1)
temp = arr[0][1] * arr[0][2] // arr[1][2]
ans = int(temp ** 0.5)
print(ans, end=' ')
for i in range(1, n):
	print(arr[0][i] // ans, end=' ')
print()


n = int(input())
m = []
for i in range(n):
	m.append(list(map(int, input().split())))
x = m[1][2]
y = m[0][2] / m[0][1]
a3 = int((x * y) ** 0.5)
a2 = x // a3
a1 = m[0][1] // a2
a = [a1, a2, a3]
for i in range(3, n):
	a.append(m[0][i] // a1)
print(*a)


n = int(input())
a = [0] * n
b = [list(map(int, input().split())) for _ in range(n)]
a[0] = int((b[0][1] * b[0][2] // b[1][2]) ** (1 / 2))
for i in range(1, n):
	a[i] = b[i][0] // a[0]
print(*a)


import math
import sys
import collections
import itertools

def getdict(n):
	d = {}
	if type(n) is list:
		for i in n:
			if i in d:
				d[i] += 1
			else:
				d[i] = 1
	else:
		for i in range(n):
			t = ii()
			if t in d:
				d[t] += 1
			else:
				d[t] = 1
	return d

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 1
	prime[0] = prime[1] = False
	r = [p for p in range(n + 1) if prime[p]]
	return r

def cdiv(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def prr(a, sep=' '):
	print(sep.join(map(str, a)))

def dd():
	return collections.defaultdict(int)

def divs(n):
	list = []
	list1 = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				list.append(i)
			else:
				list.append(i)
				list1.append(int(n / i))
	return list + list1
n = ii()
d = []
for i in range(n):
	d.append(li())
g = d[0][1]
for j in range(2, n):
	g = math.gcd(g, d[0][j])
i = 1
div = divs(g)
for i in div:
	r = [i]
	f = True
	for j in range(1, n):
		r.append(d[0][j] // i)
	for k in range(1, n):
		for j in range(k + 1, n):
			if d[k][j] // r[k] != d[k - 1][j] // r[k - 1]:
				f = False
				break
		if not f:
			break
	if f:
		exit(print(' '.join(map(str, r))))


import math
n = int(input())
matrix = []
for i in range(n):
	matrix.append(list(map(int, input().split())))
a1 = math.sqrt(matrix[1][0] * matrix[2][0] / matrix[2][1])
s = '' + str(int(a1)) + ' '
for i in range(1, n):
	s += str(int(matrix[i][0] / a1)) + ' '
print(s)


import os
import sys
from io import BytesIO, IOBase

def check(b, x, n):
	a = [x]
	for i in range(1, n):
		a.append(b[0][i] // a[0])
	for i in range(1, n):
		for j in range(i):
			if a[i] * a[j] != b[i][j]:
				return
	print(*a)
	exit(0)

def main():
	n = int(input())
	b = [list(map(int, input().split())) for _ in range(n)]
	(z, c, i) = (b[0][1], [], 1)
	while i * i <= z:
		if not z % i:
			if z // i != i:
				c.append(z // i)
			c.append(i)
		i += 1
	for i in c:
		check(b, i, n)
		check(b, z // i, n)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


n = int(input())
a = [list(map(int, input().split())) for i in range(n)]
b = a[0][2] / a[1][2]
c = a[0][1] / b
g = c ** 0.5
h = g
a[1][1] = g * g
for i in range(1, n + 1):
	g = a[1][i - 1] / h
	print(int(g), end=' ')


n = int(input())
a = []
for i in range(n):
	a.append(list(map(int, input().split(' '))))
res = []
for i in range(n - 2):
	temp = a[i][i + 1] * a[i][i + 2]
	temp = temp // a[i + 1][i + 2]
	temp = int(temp ** 0.5)
	res.append(temp)
temp = a[n - 2][0] * a[n - 2][n - 1]
temp = temp // a[0][n - 1]
res.append(int(temp ** 0.5))
temp = a[n - 1][0] * a[n - 1][1]
temp = temp // a[0][1]
res.append(int(temp ** 0.5))
print(*res)


import math
n = int(input())
arr = []
for i in range(n):
	arr1 = list(map(int, input().split()))
	arr.append(arr1)
cor = []
s1 = arr[2][0] * arr[0][1] // arr[2][1]
arr[0][0] = s1
cor.append(s1)
for i in range(1, n):
	s = arr[i][i - 1] * arr[i - 1][i] // arr[i - 1][i - 1]
	arr[i][i] = s
	cor.append(arr[i][i])
for i in range(len(cor)):
	print(int(math.sqrt(cor[i])), end=' ')


from math import sqrt
n = int(input())
table = []
for i in range(n):
	table.append([int(i) for i in input().split()])
original = []
a2 = int(sqrt(table[0][1] * table[1][2] / table[0][2]))
a1 = int(table[0][1] / a2)
a3 = int(table[1][2] / a2)
original.append(a1)
original.append(a2)
original.append(a3)
for i in range(3, n):
	original.append(int(table[0][i] / a1))
res = ''
for nb in original:
	res += str(nb) + ' '
print(res)


from math import sqrt
n = int(input())
l = []
for i in range(n):
	s = input().split()
	s = list(map(int, s))
	l.append(s)
x1 = int(l[0][1] / sqrt(l[0][1] * l[1][2] / l[0][2]))
a = [str(x1)]
for el in l[0][1:]:
	a.append(str(el // x1))
print(' '.join(a))


n = int(input())
ar = []
for i in range(n):
	ar.append(list(map(int, input().split())))
a1 = int((ar[0][1] * ar[0][2] / ar[1][2]) ** (1 / 2))
print(a1, end=' ')
for i in range(1, n):
	print(ar[0][i] // a1, end=' ')


from math import sqrt
n = int(input())
mas = []
new = []
for i in range(n):
	mas.append([])
	new = list(map(int, input().split()))
	for j in range(n):
		mas[i].append(new[j])
tmp = mas[1][2] * mas[0][2] / mas[0][1]
answer = [0] * n
answer[2] = sqrt(tmp)
for i in range(n):
	if i == 2:
		continue
	else:
		answer[i] = mas[i][2] / sqrt(tmp)
for i in range(n):
	print(int(answer[i]), end=' ')


n = eval(input())
mat = []
for i in range(n):
	mat.append(list(map(int, input().split())))
ls = []
for i in range(n - 2):
	x = mat[i][i + 1] * mat[i][i + 2]
	x = x // mat[i + 1][i + 2]
	ls.append(int(x ** 0.5))
ls.append(mat[0][n - 2] // ls[0])
ls.append(mat[0][n - 1] // ls[0])
print(' '.join([str(x) for x in ls]))


import math
temp = list(map(int, input().split()))
n = temp[0]
b = [[0 for i in range(0, n)] for i in range(0, n)]
a = [0 for i in range(0, n)]
for i in range(0, n):
	temp = list(map(int, input().split()))
	for j in range(0, n):
		b[i][j] = temp[j]
T = b[0][1] * b[1][2] * b[0][2]
t = math.sqrt(T)
a[1] = t // b[0][2]
a[0] = b[0][1] // a[1]
for i in range(2, n):
	a[i] = b[i - 1][i] // a[i - 1]
for i in range(0, n):
	print(int(a[i]), end=' ')


import os
import sys
from math import *

def squareroot(x):
	return round(sqrt(x))
n = int(input())
r1 = list(map(int, input().strip().split()))
r2 = list(map(int, input().strip().split()))
abac = r1[1] * r1[2]
aa = abac // r2[2]
a = squareroot(aa)
v = [a]
for i in range(1, n):
	x = r1[i] // a
	v.append(x)
print(' '.join(map(str, v)))


n = int(input())
mat = [[*map(int, input().split())] for _ in range(n)]
l = [1] * n
for i in range(n):
	l[i] = int((mat[i][(i + 1) % n] * mat[i][(i + 2) % n] // mat[(i + 1) % n][(i + 2) % n]) ** 0.5)
print(*l)


import math

def main():
	n = int(input())
	a = []
	for i in range(n):
		a.append([int(i) for i in input().split()])
	prod = a[0][1] * a[0][2] * a[1][2]
	ans = int(math.sqrt(prod))
	num = []
	num.append(int(ans / a[1][2]))
	num.append(int(ans / a[0][2]))
	num.append(int(ans / a[0][1]))
	for i in range(3, n):
		num.append(int(a[i][0] / num[0]))
	for i in range(n):
		print(num[i], end=' ')
	print()
main()


import sys, math, queue
MOD = 10 ** 9 + 7
sys.setrecursionlimit(1000000)
n = int(input())
a = []
x = []
for i in range(n):
	a.append(list(map(int, input().split())))
x.append(a[0][1] * a[0][2] // a[1][2])
x[0] = int(math.sqrt(x[0]))
for i in range(1, n):
	x.append(a[i][0] // x[0])
print(*x)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def IF(c, t, f):
	return t if c else f

def YES(c):
	return IF(c, 'YES', 'NO')

def Yes(c):
	return IF(c, 'Yes', 'No')

class Prime:

	def __init__(self, n):
		self.M = m = int(math.sqrt(n)) + 10
		self.A = a = [True] * m
		a[0] = a[1] = False
		self.T = t = [2]
		for j in range(4, m, 2):
			a[j] = False
		for i in range(3, m, 2):
			if not a[i]:
				continue
			t.append(i)
			for j in range(i * i, m, i):
				a[j] = False
		self.ds_memo = {}
		self.ds_memo[1] = set([1])

	def is_prime(self, n):
		return self.A[n]

	def division(self, n):
		d = collections.defaultdict(int)
		for c in self.T:
			while n % c == 0:
				d[c] += 1
				n //= c
			if n < 2:
				break
		if n > 1:
			d[n] += 1
		return d.items()

	def divisions(self, n):
		if n in self.ds_memo:
			return self.ds_memo[n]
		for c in self.T:
			if n % c == 0:
				rs = set([c])
				for cc in self.divisions(n // c):
					rs.add(cc)
					rs.add(cc * c)
				self.ds_memo[n] = rs
				return rs
		rs = set([1, n])
		self.ds_memo[n] = rs
		return rs

def main():
	t = 1
	rr = []
	for _ in range(t):
		n = I()
		aa = [LI() for _ in range(n)]
		g = aa[0][1]
		for c in aa[0][2:]:
			g = math.gcd(g, c)
		r = []
		pr = Prime(g)
		for d in pr.divisions(g):
			t = [d]
			for c in aa[0][1:]:
				t.append(c // d)
			ok = 1
			for i in range(1, n):
				if not ok:
					break
				for j in range(i + 1, n):
					if t[i] * t[j] != aa[i][j]:
						ok = 0
						break
			if ok:
				r = t
				break
		rr.append(JA(r, ' '))
	return JA(rr, '\n')
print(main())


def sq(a):
	l = 1
	r = a
	while l + 1 != a:
		c = (l + r) // 2
		if c * c < a:
			l = c
		elif c * c > a:
			r = c
		else:
			return c
n = int(input())
a = [[] * n] * n
for i in range(0, n):
	a[i] = [int(i) for i in input().split()]
for i in range(0, n):
	rb = (i + n - 1) % n
	ii = (i + n - 2) % n
	print(sq(a[i][ii] * a[i][rb] // a[rb][ii]))


import math
n = int(input())
x = list(map(int, input().split()))
y = list(map(int, input().split()))
dum = int(math.sqrt(x[1] * x[2] * y[2]))
a = int(dum / y[2])
b = int(dum / x[2])
c = int(dum / x[1])
print(str(a) + ' ' + str(b) + ' ' + str(c), end=' ')
for i in range(3, n):
	print(int(x[i] / a), end=' ')


from math import *
n = int(input())
v = [[int(g) for g in input().split()] for i in range(n)]
n1 = int(sqrt(v[0][1] * v[0][2] / v[1][2]))
print(n1, end=' ')
for i in range(1, n):
	print(v[0][i] // n1, end=' ')


import math
n = int(input())
m = []
for i in range(3):
	m.append([int(x) for x in input().split()])
a = [0] * n
a[1] = math.sqrt(m[0][1] * m[1][2] // m[0][2])
for i in range(n):
	if i != 1:
		a[i] = m[1][i] // a[1]
for x in a:
	print(int(x), end=' ')


n = int(input())
l = [[10]]
a = l
for i in range(n):
	in_ = list(map(int, input().split()))
	l.append([0] + in_)
ans = [0 for i in range(n + 10)]
for i in range(3, n + 1):
	ans[i] = l[i][1] * l[2][i] / a[1][2]
	ans[i] = int(ans[i] ** 0.5)
ans[1] = int(a[1][3] / ans[3])
ans[2] = int(a[2][3] / ans[3])
for i in ans[1:n + 1]:
	print(i, end=' ')
print('')


import math
n = int(input())
M = []
for _ in range(n):
	M.append(list(map(int, input().split())))
res = [0 for _ in M]
for i in range(len(M) - 1, 1, -1):
	res[i] = int(math.sqrt(M[i][i - 1] * M[i][i - 2] / M[i - 1][i - 2]))
res[1] = M[1][2] // res[2]
res[0] = M[0][1] // res[1]
print(res[0])
for i in range(1, len(res)):
	print(' ' + str(res[i]))


import math
num = int(input())
arr = []
for i in range(num):
	x = []
	x = list(map(int, input().split()))
	arr.append(x)
result = ''
if num == 2 and arr[0][1] % 2 == 0:
	a1 = 2
	a2 = int(arr[0][1] / 2)
	result += str(a1)
	result += ' '
	result += str(a2)
	print(result)
if num == 2 and arr[0][1] % 2 == 1:
	a1 = 1
	a2 = arr[0][1]
	result += str(a1)
	result += ' '
	result += str(a2)
	print(result)
else:
	last = arr[num - 1][0]
	l = arr[num - 2][0]
	a = arr[num - 1][num - 2]
	re = int(math.sqrt(last * l / a))
	result += str(re)
	result += ' '
	for i in range(num - 2):
		last = arr[0][i + 1]
		l = arr[0][i + 2]
		a = arr[i + 1][i + 2]
		re = int(math.sqrt(last * a / l))
		result += str(re)
		result += ' '
	last = arr[0][num - 1]
	l = arr[num - 2][num - 1]
	a = arr[num - 2][0]
	re = int(math.sqrt(last * l / a))
	result += str(re)
	result += ' '
	print(result)


n = int(input())
arr = [list(map(int, input().split())) for _ in range(n)]
nums = [int((arr[0][1] * arr[0][2] // arr[1][2]) ** 0.5)]
for n in arr[0][1:]:
	nums.append(n // nums[0])
print(*nums)


from math import sqrt
n = int(input())
m = []
for i in range(n):
	m.append(list(map(int, input().strip().split())))
a = []
x = m[n - 1][n - 2]
for i in range(n - 2):
	a.append(int(sqrt(m[n - 1][i] * m[n - 2][i] / x)))
a.append(int(sqrt(m[0][n - 2] * m[n - 1][n - 2] / m[0][n - 1])))
a.append(int(sqrt(m[0][n - 1] * m[1][n - 1] / m[0][1])))
print(' '.join(map(str, a)))


from math import gcd

def factor(x):

	def f(y, q):
		while not y % q:
			y //= q
			r[q] = r.get(q, 0) + 1
		return y
	(r, p) = ({}, 7)
	x = f(f(f(x, 2), 3), 5)
	while x >= p * p:
		for s in (4, 2, 4, 2, 4, 6, 2, 6):
			if not x % p:
				x = f(x, p)
			p += s
	if x > 1:
		f(x, x)
	return r

def divisors(x):
	r = [1]
	for (p, n) in factor(x).items():
		t = -len(r)
		for _ in range(n):
			for _ in range(t, 0):
				r.append(r[t] * p)
	return r

def main():
	n = int(input())
	l = [e for _ in range(n) for e in map(int, input().split())]
	m = min(filter(None, l))
	(y, x) = divmod(l.index(m), n)
	(row, col) = (l[y * n:(y + 1) * n], l[x:n * n:n])
	for (a, b) in zip(row, col):
		if a and b:
			break
	for c in divisors(m):
		d = m // c
		if all((a * d == b * c for (a, b) in zip(row, col) if a and b)):
			row = [e // c for e in row]
			row[y] = c
			print(*row)
			return
main()


import sys, math

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def main():

	def input():
		return sys.stdin.readline()[:-1]
	n = int(input())
	T = [list(map(int, input().split())) for k in range(n)]
	N = T[0][1]
	for k in range(2, n):
		N = gcd(N, T[0][k])
	P = [1, N]
	for k in range(2, math.floor(math.sqrt(N)) + 1):
		if N % k == 0:
			P.append(k)
			P.append(N // k)
	P = sorted(P)[::-1]
	for e in P:
		A = [e] + [T[0][k] // e for k in range(1, n)]
		t = A[1]
		f = 1
		for k in range(n):
			if k != 1:
				if T[1][k] != A[k] * t:
					f = 0
					break
		if f == 1:
			print(*A, sep=' ')
			exit(0)
main()


import math
n = int(input())
a = []
for _ in range(n):
	tmp = list(map(int, input().split()))
	a.append(tmp)
x = n * [None]
for i in range(n):
	solved = False
	for j in range(n):
		for k in range(n):
			if i != j and j != k and (k != i):
				xi = int(math.sqrt(a[i][j] * a[i][k] / a[k][j]))
				x[i] = xi
				solved = True
				break
		if solved:
			break
print(' '.join(list(map(str, x))))


n = int(input())
a = [list(map(int, input().split())) for i in range(n)]
a1 = round((a[0][1] * a[0][2] // a[1][2]) ** 0.5)
print(a1, end=' ')
for i in range(1, n):
	print(a[i][0] // a1, end=' ')


import math
n = int(input())
first = input()
ans = []
first = int(input().split()[0])
second = list(map(int, input().split()))
ans.append(int(math.sqrt(second[0] * second[1] // first)))
ans = [second[1] // ans[0]] + ans
ans = [second[0] // ans[1]] + ans
for i in range(n - 3):
	second = list(map(int, input().split()))
	ans.append(int(math.sqrt(second[0] * second[1] // first)))
print(*ans)


from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def LS():
	return [list(x) for x in sys.stdin.readline().split()]

def S():
	res = list(sys.stdin.readline())
	if res[-1] == '\n':
		return res[:-1]
	return res

def IR(n):
	return [I() for i in range(n)]

def LIR(n):
	return [LI() for i in range(n)]

def SR(n):
	return [S() for i in range(n)]

def LSR(n):
	return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007

def A():
	n = I()
	s = S()
	d = defaultdict(lambda : 0)
	for i in s:
		d[i] += 1
	ans = [1] * d['n']
	d['o'] -= d['n']
	ans += [0] * d['o']
	print(*ans)
	return

def B():
	n = I()
	m = LIR(n)
	f = [0] * n
	for i in range(n):
		for j in range(n):
			if i == j:
				continue
			f[i] += math.log(m[i][j], 10)
	F = sum(f)
	p = F / (2 * (n - 1))
	a = [round(10 ** ((f[i] - p) / (n - 2))) for i in range(n)]
	print(*a)
	return

def C():
	return

def D():
	return

def E():
	return

def F():
	return

def G():
	return
B()


import math
n = int(input())
table = []
for i in range(n):
	table.append(list(map(int, input().strip().split())))
ans = []
for i in range(n):
	ans.append(int(math.sqrt(table[i][(i + 1) % n] * table[i][(i + 2) % n] / table[(i + 1) % n][(i + 2) % n])))
printed = ''
for i in ans:
	printed += ' ' + str(i)
print(printed.strip())


n = int(input())
m = [[*map(int, input().split())] for _ in range(n)]
tm = [*zip(*m)]
s = set()
from math import gcd
from functools import reduce
ans = [-1] * n
for i in range(n):
	g1 = reduce(gcd, m[i])
	g2 = reduce(gcd, tm[i])
	ans[i] = gcd(g1, g2)
z = [[-1] * n for _ in range(n)]
for i in range(n):
	for j in range(n):
		s.add(m[i][j])
		z[i][j] = ans[i] * ans[j]
s.remove(0)

def divisors(n):
	div = []
	for i in range(1, int(n ** (1 / 2)) + 1):
		if n % i == 0:
			div.append(i)
			if i * i != n:
				div.append(n // i)
	return sorted(div)
div = divisors(ans[0])
for i in div:
	res = [i] + [m[0][j] // i for j in range(1, n)]
	flag = True
	for i in range(n - 1):
		if res[i] * res[i + 1] != m[i][i + 1]:
			flag = False
			break
	if flag:
		print(*res)
		break


import math
v = int(input())
a = []
for i in range(v):
	c = [int(x) for x in input().split()]
	a.append(c)
l = a[0][1] * a[0][2] // a[1][2]
e = math.sqrt(l)
print(int(e), end=' ')
for i in range(1, v):
	print(int(a[0][i] // e), end=' ')


from math import sqrt
n = int(input())
matr = [list(map(int, input().split())) for _ in range(n)]
for i in range(n):
	print(int(sqrt(matr[i][(i + 1) % n] * matr[i][(i + 2) % n] // matr[(i + 1) % n][(i + 2) % n])), end=' ')


import math
q = int(input())
s = []
for i in range(q):
	s.append(list(map(int, input().split())))
x = s[0][1] * s[2][0] // s[1][2]
x = math.sqrt(x)
print(int(x), end=' ')
for u in s[0][1:]:
	print(int(u // x), end=' ')


n = int(input())
t = []
for i in range(n):
	t.append([int(j) for j in input().split()])
r = []
a0 = int((t[0][1] * t[0][2] / t[1][2]) ** (1 / 2))
r.append(a0)
for i in range(1, n):
	ai = t[i][0] // a0
	r.append(ai)
print(' '.join([str(i) for i in r]))


import math
import itertools
import collections

def getdict(n):
	d = {}
	if type(n) is list:
		for i in n:
			if i in d:
				d[i] += 1
			else:
				d[i] = 1
	else:
		for i in range(n):
			t = ii()
			if t in d:
				d[t] += 1
			else:
				d[t] = 1
	return d

def cdiv(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def wr(arr):
	return ' '.join(map(str, arr))

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def revn(n):
	m = 0
	while n > 0:
		m = m * 10 + n % 10
		n = n // 10
	return m
n = ii()
t = []
for i in range(n):
	t.append(li())
ans = []
ans.append(int(math.sqrt(t[0][1] * t[0][2] / t[1][2])))
for i in range(1, n):
	ans.append(int(t[0][i] / ans[0]))
print(wr(ans))


n = int(input())
mat = []
for i in range(n):
	mat.append(list(map(int, input().split())))
pro = mat[0][1] * mat[0][2]
pro = pro // mat[1][2]
pro = int(pro ** 0.5)
print(pro, end=' ')
for i in range(1, n):
	print(mat[0][i] // pro, end=' ')


import math
x = int(input())
k = x
l = []
while x:
	a1 = list(map(int, input().split()))
	l.append(a1)
	x -= 1
a1 = math.sqrt(l[0][1] * l[0][2] // l[1][2])
z = 1
print(int(a1), end=' ')
while z < k:
	print(int(l[0][z] // a1), end=' ')
	z += 1


import math
n = int(input())
m = []
for i in range(n):
	a = []
	s = input().split()
	for j in s:
		a.append(int(j))
	m.append(a)
a1a0 = m[1][0]
a2a0 = m[2][0]
a2a1 = m[2][1]
a0square = a2a0 * a1a0 // a2a1
a0 = int(math.sqrt(a0square))
a = []
a.append(a0)
for row in range(1, n):
	arowa0 = m[row][0] // a0
	a.append(arowa0)
for index in a:
	print(index, end=' ')
print()


n = int(input())
mat = []
for i in range(n):
	mat.append(list(map(int, input().split())))

def isqrt(n):
	x = n
	y = (x + 1) // 2
	while y < x:
		x = y
		y = (x + n // x) // 2
	return x
abc = isqrt(mat[0][1] * mat[0][2] * mat[1][2])
result = [abc // mat[1][2]]
for i in range(1, n):
	result.append(mat[0][i] // result[0])
print(' '.join(map(str, result)))


n = int(input())
a = [[int(j) for j in input().split()] for i in range(n)]
b = [0] * n
b[0] = int((a[0][2] * a[0][1] / a[1][2]) ** 0.5)
for i in range(1, n):
	b[i] = int(a[0][i] / b[0])
print(*b)


from math import sqrt
n = int(input())
a = []
for i in range(n):
	b = list(map(int, input().split()))
	a.append(b)
ans = [0] * n
for i in range(n - 2):
	ans[i] = int(sqrt(a[i][i + 1] * a[i][i + 2] // a[i + 1][i + 2]))
i = n - 1
aa = a[i - 2][i - 1]
bb = a[i - 2][i]
cc = a[i - 1][i]
ans[n - 2] = int(sqrt(aa * cc // bb))
ans[n - 1] = int(sqrt(bb * cc // aa))
print(*ans)


n = int(input())
l = []
for i in range(n):
	l.append(list(map(int, input().split())))
x = int((l[0][1] * l[0][2] / l[1][2]) ** 0.5)
d = [x]
for i in range(1, n):
	d.append(l[0][i] // x)
print(*d)


import math
n = int(input())
arr = [list(map(int, input().split())) for _ in range(n)]
res = []
for i in range(n):
	a = (i + 1) % n
	b = (i + 2) % n
	res.append(int(math.sqrt(arr[i][a] * arr[i][b] // arr[a][b])))
print(' '.join(map(str, res)))


n = int(input())
lst = []
k = n
while k:
	k = k - 1
	a = [int(x) for x in input().split(' ')]
	lst.append(a)
lst1 = []
x = lst[0][1] * lst[1][2] / lst[0][2]
x = int(x ** 0.5)
lst1.append(lst[0][1] // x)
lst1.append(x)
print(lst1[0], end=' ')
print(lst1[1], end=' ')
for i in range(2, len(lst[0])):
	y = lst[0][i] // lst1[0]
	print(y, end=' ')


n = int(input())
m = [list(map(int, input().split())) for i in range(n)]
from math import gcd, sqrt
gc = m[0][1]
c = m[0]
for i in range(2, n):
	gc = gcd(gc, m[0][i])

def divisors(n):
	divs = [1]
	for i in range(2, int(sqrt(n)) + 1):
		if n % i == 0:
			divs.extend([i, n / i])
	divs.extend([n])
	return list(set(divs))
a = divisors(gc)
a.sort()
a.reverse()

def chk(k):
	t = True
	ans = list(c)
	for i in range(n):
		ans[i] = int(ans[i] / k)
	ans[0] = k
	for i in range(n):
		for j in range(n):
			if i != j and ans[i] * ans[j] != m[i][j]:
				t = False
				break
		if t == False:
			break
	return t
ans = []
for rr in range(len(a)):
	if chk(int(a[rr])):
		ans = list(c)
		for i in range(n):
			ans[i] = int(ans[i] / a[rr])
		ans[0] = int(a[rr])
		break
for i in ans:
	print(i, end=' ')


from math import sqrt
n = int(input())
m_s = [[int(i) for i in input().split()] for j in range(n)]
a_s = [0] * n
a_s[0] = int(sqrt(m_s[0][1] * m_s[1][2] * m_s[2][0])) // m_s[1][2]
a_s[-1] = int(sqrt(m_s[-2][-1] * m_s[-3][-2] * m_s[-1][-3])) // m_s[-2][-3]
for i in range(1, n - 1):
	el = int(sqrt(m_s[i - 1][i] * m_s[i][i + 1] * m_s[i + 1][i - 1]))
	a_s[i] = el // m_s[i - 1][i + 1]
print(' '.join([str(i) for i in a_s]))


from math import sqrt
x = int(input())
lu = []
for __ in range(x):
	lu.append(list(map(int, input().split())))
a = lu[0][1]
b = lu[0][2]
c = lu[1][2]
d = sqrt(a * c / b)
lol = []
for i in lu[1]:
	if i == 0:
		lol.append(int(d))
	else:
		lol.append(int(i // d))
print(*lol)


from math import *
n = int(input())
l = []
for i in range(n):
	l.append(list(map(int, input().split())))
x = int(sqrt(l[0][2] / l[1][2] * l[0][1]))
print(x, end=' ')
for i in range(1, n):
	print(l[0][i] // x, end=' ')


import math
import sys
n = int(sys.stdin.readline())
M = [0] * n
for i in range(n):
	M[i] = list(map(int, sys.stdin.readline().split()))
A = [0] * n
init = M[0][1] * M[1][2] // M[0][2]
a2 = int(math.sqrt(init))
A[1] = a2
for i in range(n):
	if i != 1:
		A[i] = M[1][i] // a2
print(*A)


from math import sqrt
n = int(input())
arr = [[int(i) for i in input().split()] for j in range(n)]
ans = []
for i in range(n):
	if n - i > 2:
		ans.append(int(sqrt(arr[i][i + 1] * arr[i][i + 2] / arr[i + 1][i + 2])))
	else:
		ans.append(int(sqrt(arr[i][i - 1] * arr[i][i - 2] / arr[i - 1][i - 2])))
print(*ans)


from fractions import gcd
n = int(input())
field = []
for i in range(n):
	field.append([int(item) for item in input().split()])
val = field[0][0]
for item in field[0][:]:
	val = gcd(val, item)

def divisors(n):
	divisors = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			divisors.append(i)
			if i != n // i:
				divisors.append(n // i)
	divisors.sort()
	return divisors
div = divisors(val)
for item in div:
	a = field[0][1] // item
	b = field[0][2] // item
	c = field[1][2]
	if a * b == c:
		ans = [item]
		for ret in field[0][1:]:
			ans.append(ret // item)
		break
print(' '.join([str(item) for item in ans]))


import sys
input = sys.stdin.readline
from collections import *
n = int(input())
M = [list(map(int, input().split())) for _ in range(n)]
ans = [-1] * n
ans[0] = int((M[0][1] * M[0][2] // M[1][2]) ** 0.5)
for i in range(1, n):
	ans[i] = M[0][i] // ans[0]
print(*ans)


_ = input()
(f_col, s_col) = [[int(i) for i in input().split()] for _ in range(2)]
x = int((f_col[1] * f_col[2] / s_col[2]) ** 0.5)
print(x, *(y // x for y in f_col[1:]))


import math
n = int(input())
a = []
for i in range(n):
	l = list(map(int, input().split()))
	a.append(l)
for i in range(n):
	if i == 0:
		x = a[0][1] * a[0][2]
		x = x // a[1][2]
		y = math.sqrt(x)
		y = int(y)
		print(y, end=' ')
	elif i == n - 1:
		x = a[n - 3][n - 1] * a[n - 2][n - 1]
		x = x // a[n - 3][n - 2]
		y = math.sqrt(x)
		y = int(y)
		print(y, end=' ')
	else:
		x = a[i][i - 1] * a[i][i + 1]
		x = x // a[i - 1][i + 1]
		y = math.sqrt(x)
		y = int(y)
		print(y, end=' ')


import sys
input = sys.stdin.readline
t = 1
for _ in range(t):
	n = int(input())
	a = [[int(x) for x in input().split()] for y in range(n)]
	ans = [0] * n
	ans[0] = a[0][1] * a[0][2] // a[1][2]
	low = 1
	high = ans[0] - 1
	while low <= high:
		mid = (low + high) // 2
		if mid * mid == ans[0]:
			ans[0] = mid
			break
		elif mid * mid < ans[0]:
			low = mid + 1
		else:
			high = mid - 1
	for i in range(1, n):
		ans[i] = a[0][i] // ans[0]
	print(*ans)


import collections, heapq, bisect, math

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def solve(A):
	a1 = int(math.sqrt(A[0][2] * A[0][1] // A[1][2]))
	out = [a1]
	for i in range(1, len(A)):
		out.append(A[0][i] // a1)
	return ' '.join([str(a) for a in out])
q = input()
tests = []
for test in range(int(q)):
	tests.append([int(p) for p in input().split(' ')])
print(solve(tests))


import sys
import math as m

def fi():
	return sys.stdin.readline()
n = int(fi())
l = []
for i in range(n):
	l.append(list(map(int, fi().split())))
a = m.ceil((l[2][0] * l[1][0] / l[2][1]) ** 0.5)
print(a, end=' ')
for i in range(1, n):
	print(l[i][0] // a, end=' ')


from math import *
n = int(input())
a = []
for i in range(n):
	a.append(list(map(int, input().split())))
x = 0
for i in range(n):
	x = gcd(x, a[0][i])
ans = [0] * n
for k in range(1, int(x ** 0.5 + 0.5) + 1):
	if x % k == 0:
		ans[0] = k
		for i in range(1, n):
			ans[i] = a[0][i] // k
		f = True
		for i in range(n):
			for j in range(i + 1, n):
				if i != j:
					if ans[i] * ans[j] != a[i][j]:
						f = False
						break
			if not f:
				break
		if f:
			print(*ans)
			exit(0)
		k = x // k
		ans[0] = k
		for i in range(1, n):
			ans[i] = a[0][i] // k
		f = True
		for i in range(n):
			for j in range(i + 1, n):
				if i != j:
					if ans[i] * ans[j] != a[i][j]:
						f = False
						break
			if not f:
				break
		if f:
			print(*ans)
			exit(0)


def gns():
	return list(map(int, input().split()))
n = int(input())
ns = []

def gcd(a, b):
	if a % b == 0:
		return b
	else:
		return gcd(b, a % b)
for i in range(n):
	ns.append(gns())
a1 = ns[0][1]
a2 = ns[0][2]
g = gcd(a1, a2)
a1 = a1 // g
a2 = a2 // g
a12 = ns[1][2]
import math
x = int(math.sqrt(a12 // a1 // a2))
for y in range(x - 1, x + 2):
	if y * y * a1 * a2 == a12:
		break
a1 = y * a1
ans = [None] * n
ans[1] = a1
for i in range(n):
	if i == 1:
		continue
	ans[i] = ns[1][i] // a1
print(' '.join(map(str, ans)))


from math import gcd
n = int(input())
a = []
pret = []
for i in range(n):
	b = [int(x) for x in input().split()]
	a.append(b)
arr = 0
for item in a[0]:
	arr = gcd(arr, item)
for item in a[0]:
	if item != 0:
		pret.append(item // arr)
counter = int((a[1][2] // (pret[0] * pret[1])) ** 0.5)
tot = [arr // counter]
for item in pret:
	tot.append(item * counter)
print(*tot)


n = int(input())
a = [0] * n
for i in range(n):
	a[i] = list(map(int, input().split()))
x = int((a[0][2] * a[1][2] // a[1][0]) ** 0.5)
for i in range(n):
	if a[2][i] == 0:
		print(x, end=' ')
	else:
		print(a[2][i] // x, end=' ')


import math as mp
n = int(input())
li = []
a = []
for _ in range(n):
	li.append(list(map(int, input().split())))
for i in range(n):
	a.append(0)
k = mp.floor(n / 2)
a[k] = round(pow(li[k][k - 1] * li[k][k + 1] / li[k - 1][k + 1], 0.5))
try:
	for i in range(k - 1, -1, -1):
		a[i] = int(li[i + 1][i] // a[i + 1])
except:
	pass
for i in range(k + 1, n, 1):
	a[i] = int(li[i][i - 1] // a[i - 1])
for i in a:
	print(i, end=' ')


from math import sqrt
n = int(input())
arr = [1] * n
lines = [0] * n
for i in range(n):
	lines[i] = list(map(int, input().split(' ')))
sol = [0] * n

def solve(index):
	sol[index] = 1
	axb = lines[index][index + 1]
	axc = lines[index][index + 2]
	bxc = lines[index + 1][index + 2]
	axbxc = int(sqrt(axb * axc * bxc))
	sol[index] = axbxc // bxc
	sol[index + 1] = axbxc // axc
	sol[index + 2] = axbxc // axb
for i in range(n - 2):
	solve(i)
print(' '.join(list(map(str, sol))))


from sys import stdin, stdout
import math
N = int(stdin.readline())
matrix = []
for i in range(N):
	matrix.append([int(x) for x in stdin.readline().split()])
ans = [0 for i in range(N)]
for i in range(N - 2):
	x = matrix[i][i + 1] * matrix[i + 1][i + 2] // matrix[i][i + 2]
	x = int(math.sqrt(x))
	ans[i + 1] = x
ans[0] = matrix[0][1] // ans[1]
ans[N - 1] = matrix[N - 2][N - 1] // ans[N - 2]
print(*ans)


def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
from functools import reduce
from math import sqrt
import sys
readline = sys.stdin.readline
N = int(readline())
G = [list(map(int, readline().split())) for _ in range(N)]
Gzr = G[0]
h = reduce(gcd, Gzr)
j = int(sqrt(h * h * G[1][2] // G[0][1] // G[0][2]))
h //= j
ans = [h] + [g // h for g in Gzr[1:]]
print(*ans)


from math import ceil, sqrt, log, gcd

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())

def main():
	n = ii()
	a = []
	for i in range(n):
		a.append(li())
	c = a[0][1] * a[0][2] // a[1][2]
	x = sqrt(c)
	x = int(x)
	print(x, end=' ')
	for i in range(1, n):
		print(a[0][i] // x, end=' ')
main()


from math import *
n = int(input())
l = [[int(j) for j in input().split()] for i in range(n)]
g = []
for x in range(n):
	flag = 0
	d = 0
	for y in range(n):
		if flag:
			break
		for z in range(n):
			a = l[x][y]
			b = l[x][z]
			c = l[y][z]
			if a and b and c:
				flag = 1
				d = a * b // c
				break
	g.append(int(sqrt(d)))
print(*g)


n = int(input())
arr = []
for i in range(n):
	l = list(map(int, input().split()))
	arr.append(l)
a = arr[0][1] * arr[0][2] * arr[0][1]
b = arr[1][0] * arr[1][2]
xx = (a // b) ** 0.5
x = int(xx)
print(x, end=' ')
for i in range(1, n):
	print(arr[0][i] // x, end=' ')
print()


import math

def find_gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
n = int(input())
a = []
for i in range(n):
	l = list(map(int, input().split()))
	a.append(l)
x = a[0][1] * a[0][2] // a[1][2]
b = int(math.sqrt(x))
print(b, end=' ')
for i in range(n - 1):
	print(a[0][i + 1] // b, end=' ')


import math
n = int(input())
table = []
for i in range(n):
	temp = [int(k) for k in input().split()]
	table.append(temp)
answer = []
for i in range(n):
	l = int(table[i - 1][i] * table[i - 2][i] // table[i - 1][i - 2])
	answer.append(int(math.sqrt(l)))
print(' '.join([str(i) for i in answer]))


n = input()
a = [*map(int, input().split())]
a[0] = a[1] * a[2] // int(input().split()[2])
print(*[int(_ / a[0] ** 0.5) for _ in a])


import sys
input = sys.stdin.readline
import math
n = int(input())
MAP = [list(map(int, input().split())) for i in range(n)]
MIN = 1 << 50
SUM = [sum(MAP[i]) for i in range(n)]
minind = SUM.index(min(SUM))
GCD = 0
for m in MAP[minind]:
	if m != 0:
		GCD = math.gcd(GCD, m)
x = GCD
import math
xr = math.ceil(math.sqrt(x))
LIST = []
for i in range(1, xr + 1):
	if x % i == 0:
		LIST.append(i)
		LIST.append(x // i)
for l in LIST:
	ANS = [-1] * n
	ANS[minind] = l
	for i in range(n):
		if i != minind:
			ANS[i] = MAP[minind][i] // l
	flag = 1
	for i in range(n):
		for j in range(n):
			if i != j and ANS[i] * ANS[j] == MAP[i][j]:
				continue
			if i == j:
				continue
			else:
				flag = 0
				break
		if flag == 0:
			break
	if flag == 1:
		break
print(*ANS)


import math
n = int(input())
l = []
for i in range(n):
	l.append(input().split())
for i in range(n):
	if i < n - 2:
		r = int(l[i][i + 1]) * int(l[i][i + 2]) // int(l[i + 1][i + 2])
	elif i == n - 2:
		r = int(l[i][i + 1]) * int(l[i][0]) // int(l[i + 1][0])
	else:
		r = int(l[i][0]) * int(l[i][1]) // int(l[0][1])
	print(int(math.sqrt(r)), end=' ')


import math
n = int(input())
l = []
for t in range(n):
	x = list(map(int, input().split()))
	l.append(x)
ss = l[0][1] * l[0][n - 1] // l[1][n - 1]
q = int(math.sqrt(ss))
print(q, end=' ')
for vv in range(1, n):
	print(l[0][vv] // q, end=' ')


from math import sqrt
n = int(input())
flag = True
ans = []
a1 = input().split()
a1 = list(map(int, a1))
a2 = input().split()
a2 = list(map(int, a2))
a3 = input().split()
a3 = list(map(int, a3))
ans.append(a1[1] * a1[2] // a2[2])
ans.append(a2[0] * a2[2] // a1[2])
ans.append(a3[0] * a3[1] // a2[0])
for j in range(3, n):
	a = input().split()
	a = list(map(int, a))
	ans.append(a[0] * a[1] // a1[1])
for i in range(n):
	print(int(sqrt(ans[i])), end=' ')


import math
n = int(input())
l = []
for i in range(n):
	temp = list(map(int, input().split()))
	l.append(temp)
p = []
div = []
t = 1
ans = []
for i in range(n - 2):
	p.append(l[i][t] * l[i][t + 1])
	div.append(l[i + 1][t + 1])
	t += 1
for i in range(n - 2):
	ans.append(int(math.sqrt(p[i] // div[i])))
ans.append(l[n - 3][n - 2] // ans[n - 3])
ans.append(l[n - 3][n - 1] // ans[n - 3])
print(*ans)


from math import *
n = int(input())
m = [list(map(int, input().split())) for i in range(n)]
m[0][0] = int(sqrt(m[0][2] * m[0][1] // m[1][2]))
for i in range(1, n):
	m[i][i] = m[i - 1][i] // m[i - 1][i - 1]
for i in range(n):
	print(m[i][i], end=' ')


n = int(input())
m = list()
for _ in range(n):
	x = list(map(int, input().split()))
	m.append(x)
p = [0, 1, 2]
ans = list()
for i in range(n):
	(x, y) = [x for x in p if x != i][:2]
	ans.append(int((m[i][x] * m[i][y] // m[x][y]) ** 0.5))
print(' '.join(map(str, ans)))


import sys
input = sys.stdin.readline
n = int(input())
A = [list(map(int, input().split())) for i in range(n)]
from math import ceil, sqrt
ANS = []
tmp = A[0][1] * A[0][2] // A[1][2]
ANS.append(ceil(sqrt(tmp)))
for i in range(1, n):
	ANS.append(A[0][i] // ANS[0])
print(*ANS)


from sys import stdin
import math
n = int(stdin.readline().strip())
matrix = []
for _ in range(n):
	temp = list(map(int, stdin.readline().split()))
	matrix.append(temp)
f = matrix[0][1] * matrix[0][2]
s = matrix[1][2]
first = int((f // s) ** 0.5)
ans = [first]
for i in range(1, n):
	ans.append(matrix[0][i] // first)
print(*ans)


import math
import sys
n = int(input())
arr = []
for i in range(n):
	line = sys.stdin.readline().split(' ')
	arr.append(line)
ans = []
a = int(math.sqrt(int(arr[0][1]) * int(arr[0][2]) / int(arr[1][2])))
ans.append(str(a))
for i in range(1, n):
	ans.append(str(int(arr[0][i]) // a))
print(' '.join(ans))


n = int(input())
arr = []
st = ''
for i in range(0, n):
	s = input()
	arr.append(s.split())
for j in range(0, n):
	if j == 0:
		num = int((int(arr[0][1]) * int(arr[0][2]) / int(arr[1][2])) ** (1 / 2))
		st = str(num)
	if j == 1:
		num = int((int(arr[1][0]) * int(arr[1][2]) / int(arr[0][2])) ** (1 / 2))
		st = st + ' ' + str(num)
	if j == 2:
		num = int((int(arr[2][0]) * int(arr[2][1]) / int(arr[0][1])) ** (1 / 2))
		st = st + ' ' + str(num)
	if j > 2:
		num = int((int(arr[j][0]) * int(arr[j][1]) / int(arr[0][1])) ** (1 / 2))
		st = st + ' ' + str(num)
print(st)


import math
t = [[] for i in range(1005)]
n = int(input())
for i in range(n):
	string = input().split(' ')
	for c in string:
		t[i].append(int(c))
ans = []
ans.append(math.sqrt(t[0][1] * t[0][2] / t[1][2]))
for i in t[0][1:]:
	ans.append(i / ans[0])
for each in ans:
	print(int(each), end=' ')


import math
I = input
n = int(I())
a = [[int(i) for i in I().split(' ')] for j in range(n)]
ans = []
a1 = int(math.sqrt(a[0][1] * a[0][2] // a[1][2]))
ans.extend([a1, a1 * a[1][2] // a[0][2]])
for i in range(2, n):
	ans.append(a[i - 1][i] // ans[i - 1])
for i in ans:
	print(i, end=' ')


n = int(input())
table = [[None for i in range(n)] for j in range(n)]
for i in range(n):
	table[i] = [int(a) for a in input().split()]
answers = []
for i in range(n - 2):
	answers.append(int((table[i][i + 1] * table[i][i + 2] / table[i + 1][i + 2]) ** 0.5 + 0.1))
answers.append(int((table[n - 3][n - 2] + answers[-1] - 1) / answers[-1]))
answers.append(int((table[n - 2][n - 1] + answers[-1] - 1) / answers[-1]))
print(*answers, sep=' ')


import atexit
import io
import sys
_I_B = sys.stdin.read().splitlines()
input = iter(_I_B).__next__
_O_B = io.StringIO()
sys.stdout = _O_B

@atexit.register
def write():
	sys.__stdout__.write(_O_B.getvalue())

def main():
	n = int(input())
	m = []
	for i in range(n):
		m.append(list(map(int, input().split())))
	a1 = int((m[0][2] * m[0][1] // m[1][2]) ** 0.5)
	print(a1, end=' ')
	for i in range(1, n):
		print(m[0][i] // a1, end=' ')
main()


import math

def div(a):
	l = list()
	for i in range(1, int(pow(a + 1, 0.5)) + 1):
		if a % i == 0:
			l.append(i)
			l.append(a // i)
	return l
n = int(input())
a = list()
l1 = list()
for i in range(0, n):
	l = list(map(int, input().split()))
	a.append(l)
l1 = div(math.gcd(a[0][1], a[0][2]))
ans = 1
for i in l1:
	a1 = a[0][1] / i
	a2 = a[0][2] / i
	if a1 * a2 == a[2][1]:
		ans = i
		break
print(int(ans), end=' ')
for i in range(1, n):
	j = a[0][i] / ans
	print(int(j), end=' ')


import math
n = int(input())
l = []
for j in range(n):
	inp = list(map(int, input().split()))
	l.append(inp)
a2 = int(math.sqrt(l[1][2] * l[0][1] / l[0][2]))
a1 = l[1][0] // a2
print(a1, a2, end=' ')
for j in range(2, n):
	print(l[1][j] // a2, end=' ')


n = int(input())
l = []
r = []
for _ in range(n):
	l.append(list(map(int, input().split())))
r.append((l[0][1] * l[0][2] / l[1][2]) ** 0.5)
for i in range(n - 1):
	r.append(l[0][i + 1] / r[0])
print(*(int(_) for _ in r))


from math import gcd
n = int(input())
a = []
for i in range(n):
	a.append(list(map(int, input().split())))
x = a[0][1] * a[0][2]
y = int((x // a[1][2]) ** 0.5)
b = [y]
for i in range(1, n):
	b.append(a[0][i] // y)
print(*b)


import math as m
n = int(input())
t = []
for i in range(n):
	t.append(list(map(int, input().split())))
print(' '.join(list(map(lambda x: str(int(m.sqrt(x))), [t[i][(i + 1) % n] * t[i][(i + 2) % n] // t[(i + 1) % n][(i + 2) % n] for i in range(n)]))))


from math import sqrt
matriz = []
n = int(input())
for i in range(n):
	matriz.append([int(x) for x in input().split()])
a1 = int(sqrt(matriz[0][1] * matriz[0][2] / matriz[1][2]))
res = [a1]
for i in range(1, n):
	res.append(matriz[0][i] // a1)
print(*res)


import math
a = int(input(''))
c = []
for i in range(a):
	b = [int(b) for b in input().split()]
	c.append(b)
s = []
for j in range(a - 2):
	f = math.pow(c[j + 1][j] * c[j + 2][j] / c[j + 1][j + 2], 0.5)
	s.append(int(f))
y = math.pow(c[a - 1][a - 2] * c[0][a - 2] / c[a - 1][0], 0.5)
z = c[0][-1] / s[0]
s.append(int(y))
s.append(int(z))
N = ''
for m in range(len(s)):
	N = N + ' ' + str(s[m])
print(N)


n = int(input())
arr = [list(map(int, input().split())) for i in range(n)]
t = int((arr[0][1] * arr[0][2] * arr[1][2]) ** 0.5)
first = t // arr[1][2]
ans = [first]
for i in range(1, n):
	ans.append(arr[0][i] // first)
print(*ans)


mod = 10 ** 9 + 7
from sys import stdin, stdout
import bisect
from bisect import bisect_left as bl
from bisect import bisect_right as br
import itertools
import collections
import math
import heapq
from random import randint as rn

def modinv(n, p):
	return pow(n, p - 2, p)

def ncr(n, r, p):
	t = fact[n] * (ifact[r] * ifact[n - r] % p) % p
	return t

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())

def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def main():
	n = int(input())
	a = []
	for i in range(n):
		l = ain()
		a.append(l)
	x = 1
	l = 1
	r = 1000000001
	while l <= r:
		mid = l + (r - l) // 2
		midd = a[0][1] // mid
		if a[1][2] * mid == a[0][2] * midd:
			break
		elif a[1][2] * mid < a[0][2] * midd:
			l = mid + 1
		else:
			r = mid - 1
	z = int(mid)
	print(z, end=' ')
	for i in range(1, n):
		print(a[0][i] // z, end=' ')
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from math import gcd
n = int(input())
d = [list(map(int, input().split())) for _ in range(n)]
a = d[0][:]
t = a[1]
for v in a[2:]:
	t = gcd(t, v)
tt = int((d[1][2] * t * t // a[1] // a[2]) ** 0.5)
t //= tt
d[0][0] = t * t
print(*map(lambda x: x // t, d[0]))


n = int(input())
m = []
for i in range(n):
	a = [int(i) for i in input().split()]
	m.append(a)
b = int((m[0][1] * m[1][2] // m[0][2]) ** 0.5)
for i in range(n):
	if i != 1:
		print(m[1][i] // b, end=' ')
	else:
		print(b, end=' ')


from fractions import gcd
from functools import reduce

def find_gcd(list):
	x = reduce(gcd, list)
	return x
n = int(input())
arr = [0]
matrix = []
for i in range(n):
	y = list(map(int, input().split()))
	matrix.append(y)
x = find_gcd(matrix[0])
for i in range(1, n):
	arr.append(matrix[0][i] // x)
m = arr[1] * arr[2]
k = matrix[1][2] // m
k = k ** 0.5
k = int(k)
i = 0
while i < n:
	arr[i] = arr[i] * k
	i += 1
arr[0] = matrix[2][0] // arr[2]
print(*arr)


import sys
import math
t = int(input())
s = []
for i in range(t):
	s.append(list(map(int, input().strip().split())))
ans = []
ans.append(math.sqrt(s[0][1] * s[0][2] / s[1][2]))
for i in range(1, t):
	ans.append(s[i][0] / ans[0])
for i in ans:
	print(int(i), end=' ')


import math
n = int(input())
M = []
for _ in range(n):
	M.append(list(map(int, input().split())))
(i, j) = (1, 2)
a = int(math.sqrt(M[0][i] * M[0][j] / M[i][j]))
print(a, end=' ')
for i in range(1, n):
	print(int(M[i][0] / a), end=' ')


M = list()
n = int(input())
for i in range(n):
	temp = list(map(int, input().split()))
	M.append(temp)
a = M[0][1] * M[0][2]
a = (a // M[1][2]) ** 0.5
a = a // 1
(i, ans) = (1, str(int(a)) + ' ')
val = list()
while i < n:
	ans += str(int(M[0][i] // a)) + ' '
	i += 1
print(ans)


n = int(input())
m = [None] * n
for i in range(n):
	m[i] = [int(x) for x in input().split()]
one = m[0][1] * m[0][2] / m[1][2]
one = int(one ** 0.5)
print(one, end=' ')
for k in range(1, n):
	print(m[0][k] // one, end=' ')


n = int(input())
matriz = [list(map(int, input().split())) for _ in range(n)]
c1 = matriz[0][1]
c2 = matriz[0][2]
c3 = matriz[1][2]
a1 = (c1 * c2 / c3) ** 0.5
a_list = [a1]
for i in range(1, n):
	a_list.append(matriz[0][i] / a1)
ans_list = list(map(int, a_list))
print(' '.join(list(map(str, ans_list))))


rows = int(input())
table = [[int(x) for x in input().split()] for _ in range(rows)]
(a, b, c) = (table[0][1], table[0][2], table[1][2])
ans = []
ans.append(int((a * b / c) ** 0.5))
for i in range(1, rows):
	ans.append(table[0][i] // ans[0])
print(*ans)


n = int(input())
tabl = []
a = []
for i in range(n):
	tabl.append([int(i) for i in input().split()])
A1A2 = tabl[0][1]
A1A3 = tabl[0][2]
A2A3 = tabl[1][2]
a1 = int((A1A2 * A1A3 / A2A3) ** 0.5)
a.append(str(a1))
for i in tabl[0][1:]:
	a.append(str(int(i / a1)))
print(' '.join(a))


def main():
	n = int(input())
	m = list()
	for i in range(n):
		x = list(map(int, input().split()))
		m.append(x)
	a = [0] * n
	a[0] = (m[0][1] * m[0][2] / m[1][2]) ** 0.5
	for i in range(1, n):
		a[i] = m[i - 1][i] / a[i - 1]
	for i in range(n):
		print(int(a[i]), end=' ')
main()


import sys
input = sys.stdin.readline
a = int(input())
n = a
import math
ans = []
for i in range(n):
	z = list(map(int, input().split()))
	ans.append(z)
t1 = ans[0][1] * ans[0][2]
t2 = ans[1][0] * ans[1][2]
m = math.gcd(t1, t2)
t1 = t1 // m
t2 = t2 // m
alpha = ans[0][1] * t2 // t1
t = int(math.sqrt(alpha))
f1 = [0 for i in range(n)]
f1[1] = t
m = ans[1]
for i in range(n):
	if i == 1:
		continue
	f1[i] = m[i] // t
print(*f1)


import math
from decimal import Decimal
import heapq

def na():
	n = int(input())
	b = [int(x) for x in input().split()]
	return (n, b)

def nab():
	n = int(input())
	b = [int(x) for x in input().split()]
	c = [int(x) for x in input().split()]
	return (n, b, c)

def dv():
	(n, m) = map(int, input().split())
	return (n, m)

def dva():
	(n, m) = map(int, input().split())
	a = [int(x) for x in input().split()]
	b = [int(x) for x in input().split()]
	return (n, m, b)

def eratosthenes(n):
	sieve = list(range(n + 1))
	for i in sieve:
		if i > 1:
			for j in range(i + i, len(sieve), i):
				sieve[j] = 0
	return sorted(set(sieve))

def lol(lst, k):
	k = k % len(lst)
	ret = [0] * len(lst)
	for i in range(len(lst)):
		if i + k < len(lst) and i + k >= 0:
			ret[i] = lst[i + k]
		if i + k >= len(lst):
			ret[i] = lst[i + k - len(lst)]
		if i + k < 0:
			ret[i] = lst[i + k + len(lst)]
	return ret

def nm():
	n = int(input())
	b = [int(x) for x in input().split()]
	m = int(input())
	c = [int(x) for x in input().split()]
	return (n, b, m, c)

def dvs():
	n = int(input())
	m = int(input())
	return (n, m)

def Factor(n):
	Ans = []
	d = 2
	while d * d <= n:
		if n % d == 0:
			Ans.append(d)
			n //= d
		else:
			d += 1
	if n > 1:
		Ans.append(n)
	return Ans
n = int(input())
a = []
for i in range(n):
	a.append(list(map(int, input().split())))
for i in range(n):
	if i == 0:
		x = i + 1
		j = i + 2
		tc1 = a[i][x]
		tc2 = a[i][j]
		print(int((tc1 * tc2 // a[x][j]) ** 0.5), end=' ')
	elif i == n - 1:
		x = i - 1
		j = i - 2
		tc1 = a[i][x]
		tc2 = a[i][j]
		print(int((tc1 * tc2 // a[x][j]) ** 0.5), end=' ')
	else:
		x = 0
		j = n - 1
		tc1 = a[i][x]
		tc2 = a[i][j]
		print(int((tc1 * tc2 // a[x][j]) ** 0.5), end=' ')


from math import sqrt
n = int(input())
r = []
m = []
for x in range(n):
	m.append(list(map(int, input().split())))
r.append(round(sqrt(m[0][1] * m[0][2] // m[1][2])))
for x in range(1, n - 1):
	r.append(round(sqrt(m[x][x - 1] * m[x][x + 1] // m[x - 1][x + 1])))
r.append(round(sqrt(m[-1][-2] * m[-1][-3] // m[-2][-3])))
print(*r)


from math import sqrt
n = int(input())
tab = []
for i in range(n):
	tab.append(list(map(int, input().split())))
lst = [int(sqrt(tab[0][1] * tab[0][2] / tab[1][2]))]
for i in range(1, n):
	lst.append(int(tab[0][i] / lst[0]))
print(' '.join(map(str, lst)))


n = int(input())
table = []
for i in range(n):
	table.append(list(map(int, input().split())))
x = table[0][1]
y = table[1][2]
z = table[0][2]
ans = [0] * n
ans[0] = int((z * x // y) ** 0.5)
for i in range(1, n):
	ans[i] = table[0][i] // ans[0]
print(*ans)


import math
n = int(input())
b = []
for _ in range(n):
	b.append([int(x) for x in input().split(' ')])
g = math.gcd(b[0][1], b[0][2])
for i in range(3, n):
	g = math.gcd(g, b[0][i])
x = b[1][2] * g * g / (b[0][1] * b[0][2])
x = pow(x, 0.5)
print(int(g / x), end=' ')
for i in range(1, n):
	print(int(b[0][i] * x / g), end=' ')
print('')


import math
n = int(input())
m = [list(map(int, input().split())) for i in range(n)]
p = m[0][1]
q = m[0][2]
r = m[1][2]
b = int(math.sqrt(p * r // q))
arr = []
for i in range(0, n):
	if i == 1:
		arr.append(b)
	else:
		arr.append(m[1][i] // b)
print(*arr)


from math import sqrt
x = int(input())
k = x
lst = []
while x:
	a1 = list(map(int, input().split()))
	lst.append(a1)
	x -= 1
a1 = sqrt(lst[0][1] * lst[0][2] // lst[1][2])
p = 1
print(int(a1), end=' ')
while p < k:
	print(int(lst[0][p] // a1), end=' ')
	p += 1


import math
n = int(input())
arr = []
for i in range(n):
	q = list(map(int, input().split()))
	arr.append(q)
x = math.sqrt(arr[0][1] * arr[2][0] // arr[1][2])
ans = [int(x)]
for k in range(n - 1):
	ans.append(arr[0][k + 1] // int(x))
print(*ans)


n = int(input())
m = []
for i in range(n):
	m.append([])
for i in range(n):
	line = input()
	arr = line.split()
	for j in range(n):
		m[i].append(int(arr[j]))
b1 = int((m[0][1] * m[0][2] / m[1][2]) ** (1.0 / 2))
print(b1)
b2 = int((m[1][0] * m[1][2] / m[0][2]) ** (1.0 / 2))
print(b2)
for i in range(n - 2):
	bi = int((m[i + 2][0] * m[i + 2][1] / m[0][1]) ** (1.0 / 2))
	print(bi)


from math import sqrt
n = int(input())
m = []
for i in range(n):
	m.append(list(map(int, input().split())))
sq = [0] * n
for i in range(n):
	if i == 1:
		sq[i] = m[i][0] * m[i][2] / m[0][2]
	elif i == 2:
		sq[i] = m[i][0] * m[i][1] / m[0][1]
	else:
		sq[i] = m[i][1] * m[i][2] / m[1][2]
for x in sq:
	print(int(sqrt(x)), end=' ')


import math
n = int(input())
a = []
for _ in range(n):
	a.append(list(map(int, input().rstrip().split())))
a_f = math.sqrt(a[n - 2][n - 1] * a[n - 2 - 1][n - 1] / a[n - 2 - 1][n - 2])
for i in range(n - 1):
	print(int(a[i][n - 1] / a_f), end=' ')
print(int(a_f))


def main():
	n = int(input())
	M = []
	for _ in range(n):
		M.append(readIntArr())
	a0Sq = M[0][1] * M[0][2] // M[1][2]
	a0 = int(pow(a0Sq, 0.5) + 1e-05)
	a = [0] * n
	a[0] = a0
	for i in range(1, n):
		a[i] = M[0][i] // a[0]
	oneLineArrayPrint(a)
	return
import sys
input = sys.stdin.buffer.readline

def oneLineArrayPrint(arr):
	print(' '.join([str(x) for x in arr]))

def multiLineArrayPrint(arr):
	print('\n'.join([str(x) for x in arr]))

def multiLineArrayOfArraysPrint(arr):
	print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))

def readIntArr():
	return [int(x) for x in input().split()]

def makeArr(defaultValFactory, dimensionArr):
	dv = defaultValFactory
	da = dimensionArr
	if len(da) == 1:
		return [dv() for _ in range(da[0])]
	else:
		return [makeArr(dv, da[1:]) for _ in range(da[0])]

def queryInteractive(i, j):
	print('? {} {}'.format(i, j))
	sys.stdout.flush()
	return int(input())

def answerInteractive(ans):
	print('! {}'.format(' '.join([str(x) for x in ans])))
	sys.stdout.flush()
inf = float('inf')
MOD = 10 ** 9 + 7
for _abc in range(1):
	main()


n = int(input())
b = []
for i in range(n):
	b.append(list(map(int, input().split())))
r = b[0][1] / b[0][2]
a2 = b[1][2] * r
a2 = int(a2 ** 0.5)
a1 = int(b[0][1] / a2)
l = [a1, a2]
for p in range(2, n):
	l.append(int(b[0][p]) / a1)
for p in range(n):
	print(int(l[p]), end=' ')


from sys import stdin
a = int(stdin.readline().rstrip())
l = []
for _ in range(a):
	al = list(map(int, stdin.readline().rstrip().split(' ')))
	l.append(al)
ab = l[0][1]
bc = l[1][2]
ac = l[0][2]
val = (ab * ac // bc) ** 0.5
print(int(val), end=' ')
for i in range(1, a):
	print(int(l[0][i] // val), end=' ')


import math
n = int(input())
mat = []
for i in range(n):
	a = list(map(int, input().split()))
	mat.append(a)
a1a2 = mat[0][1]
a2a3 = mat[1][2]
a1a3 = mat[0][2]
x = mat[0][1] * mat[0][2] / mat[1][2]
a1 = int(math.sqrt(x))
ans = [a1]
for i in range(n - 1):
	val = mat[i][i + 1] // ans[-1]
	ans.append(val)
for i in ans:
	print(i, end=' ')
print('\n', end='')


import math
n = int(input())
x = []
ans = []
x = list(filter(lambda y: y > 0, map(int, input().split())))
w = x[0] * x[1]
x = list(filter(lambda y: y > 0, map(int, input().split())))
w = int(math.sqrt(w / x[1]))
ans.append(w)
ans.append(x[0] // w)
n = n - 2
for i in range(n):
	x = list(filter(lambda y: y > 0, map(int, input().split())))
	ans.append(x[0] // w)
for i in ans:
	print(i, end=' ')


n = int(input())
M = [[0 for _ in range(n)] for _ in range(n)]
row = 0
for i in range(n):
	row = list(map(int, input().split()))
	for j in range(n):
		M[i][j] = row[j]
M[1][1] = int(M[0][1] * M[1][2] / M[0][2])
a = int(M[1][1] ** 0.5)
for i in range(n):
	b = M[i][1] // a
	print(b, end=' ')


n = int(input())
arr = [[] for i in range(n)]
a = [0] * n
for i in range(n):
	arr[i] = [int(i) for i in input().split()]
a[0] = int((arr[0][1] * arr[0][2] // arr[1][2]) ** 0.5)
for i in range(1, n):
	a[i] = arr[i][0] // a[0]
for i in range(len(a)):
	print(a[i], end=' ')


n = int(input())
grid = []
for _ in range(n):
	row = [int(i) for i in input().split()]
	grid.append(row)
a = grid[0][1]
b = grid[1][2]
c = grid[0][2]
p = (a * b * c) ** 0.5
p = int(p)
a1 = p // b
a2 = p // c
a3 = p // a
ans = [a1, a2, a3]
for i in range(3, n):
	ans.append(grid[0][i] // a1)
for i in ans:
	print(i, end=' ')
print()


from bisect import bisect_left as bl, bisect_right as br, insort
import sys
import heapq
from math import *
from collections import defaultdict as dd, deque

def data():
	return sys.stdin.readline().strip()

def mdata():
	return map(int, data().split())
mod = 998244353
n = int(data())
m = []
for i in range(n):
	m.append(list(mdata()))
l = []
for i in range(n):
	s = m[i][(i + 1) % n] * m[i][(i + 2) % n] // m[(i + 1) % n][(i + 2) % n]
	l.append(int(s ** 0.5))
print(*l)


import math

def main():
	n = int(input())
	matrix = []
	for i in range(n):
		row = []
		rowRaw = input().split()
		for j in range(n):
			row.append(int(rowRaw[j]))
		matrix.append(row)
	a1 = matrix[0][1] * matrix[0][2]
	a1 = a1 / matrix[1][2]
	a1 = round(math.sqrt(a1))
	result = []
	result.append(a1)
	for i in range(1, n):
		val = matrix[0][i]
		val /= a1
		result.append(round(val))
	for el in result:
		print(el, end=' ')
main()


r = input
n = int(r())
b = list(map(int, r().split()))
b2 = list(map(int, r().split()))
x = b[1] * b[2] * b2[2]
abc = int(x ** 0.5)
while abc ** 2 < x:
	abc += 1
while abc ** 2 > x:
	abc -= 1
a = [0] * n
a[0] = abc // b2[2]
a[1] = abc // b[2]
a[2] = abc // b[1]
for i in range(3, n):
	a[i] = b[i] // a[0]
print(' '.join(map(str, a)))


a = int(input())
z = [list(map(int, input().split())) for _ in ' ' * 2]
s = int((z[0][1] * z[0][2] // z[1][2]) ** 0.5)
print(s)
for i in range(1, a):
	print(z[0][i] // s)


import math
t = int(input())
m = []
for i in range(t):
	m.append(list(map(int, input().split())))
res = ''
for i in range(t):
	j = (i + 1) % t
	k = (i + 2) % t
	res += str(int(math.sqrt(m[i][k] * m[i][j] / m[k][j]))) + ' '
print(res)


X = []
for _ in range(int(input())):
	X.append([int(_) for _ in input().split()])
x = pow(X[0][1] * X[0][2] / X[1][2], 1 / 2)
print(int(x), end=' ')
for _ in X[0][1:]:
	print(int(_ / x), end=' ')


from math import sqrt
n = int(input())
matrix = []
for _ in range(n):
	row = list(map(int, input().split(' ')))
	matrix.append(row)
c = matrix[0][2] - matrix[0][1]
d = matrix[0][1] + matrix[0][2]
e = matrix[1][2]
a2 = e * (c - d) / (c + d)
a2 = sqrt(abs(a2))
a1 = matrix[0][1] / a2
A = [a1, a2]
for i in range(2, n):
	a_i = matrix[0][i] / a1
	A.append(a_i)
A = [str(int(x)) for x in A]
print(' '.join(A))


import math
n = int(input())
a = [[int(x) for x in input().split()] for _ in range(n)]
a12 = a[0][1] * a[0][2] / a[1][2]
a1 = int(math.sqrt(a12))
a = [a1] + [x // a1 for x in a[0][1:]]
print(*a)


from sys import stdin, stdout
import math
n = int(stdin.readline())
arr = []
for i in range(n):
	temp_arr = [int(x) for x in stdin.readline().split()]
	arr.append(temp_arr)
x1 = arr[0][n - 1] / arr[1][n - 1]
x2 = arr[0][1] / arr[2][1]
y = arr[1][2] * x1 * x2
a0 = round(math.sqrt(y))
final_arr = []
for i in range(n):
	if i == 0:
		final_arr.append(a0)
	else:
		temp = arr[0][i]
		final_arr.append(int(temp / a0))
for num in final_arr:
	stdout.write(str(num) + ' ')


n = int(input())
a = list(map(int, input().split()))[1:3]
b = list(map(int, input().split()))[2:]
for i in range(n - 2):
	c = bool(input())
d = round((a[0] * b[0] / a[1]) ** 0.5)
print(a[0] // d, d, end=' ')
for i in b:
	print(i // d, end=' ')


from math import sqrt
n = int(input())
m = {}
for i in range(n):
	line = input()
	mi = [int(x) for x in line.strip().split()]
	for j in range(n):
		if i not in m:
			m[i] = {}
		m[i][j] = mi[j]
res = []
for i in range(n):
	x = m[i][(i + 1) % n]
	y = m[i][(i + 2) % n]
	z = m[(i + 1) % n][(i + 2) % n]
	res.append(str(int(sqrt(int(x * y / z)))))
print(' '.join(res))


n = int(input())
arr = []
for _ in range(n):
	arr.append([int(x) for x in input().split()])
ans = [0 for i in range(n)]
ans[1] = int((arr[0][1] * arr[1][2] // arr[0][2]) ** 0.5)
for i in range(n):
	if i == 1:
		continue
	ans[i] = arr[1][i] // ans[1]
for i in ans:
	print(i, end=' ')


import math
size = int(input())
a1 = []
a2 = []
a1 = list(map(int, input().split()))
a2 = list(map(int, input().split()))
k1 = a1[1]
k2 = a1[2] / a2[2]
b2 = k1 / k2
fin = math.sqrt(b2)
print(int(a2[0] / fin), int(fin), end=' ')
for i in range(2, size):
	print(int(a2[i] / fin), end=' ')


import math
n = int(input())
r1 = [int(x) for x in input().split()]
r2 = [int(x) for x in input().split()]
for x in range(n - 2):
	input()
a = math.sqrt(r1[1] * r1[2] / r2[2])
r2[1] = r2[0] / a
r2[0] = a
for el in range(2, n):
	r2[el] = r2[el] / r2[1]
for a in r2:
	print(str(int(a)) + ' ', end='')


x = int(input())
s = []
v = [0] * x
for n in range(x):
	s.append(list(map(int, input().split())))
k = int((s[0][1] * s[0][2] / s[1][2]) ** 0.5)
v[0] = k
for n in range(1, x):
	v[n] = s[n][0] // k
print(*v)


from math import sqrt
num = int(input())
a = []
for i in range(num):
	m = [int(i) for i in input().split()]
	a.append(m)
nm = a[1][2] / a[0][2]
ex = round(sqrt(a[1][0] / nm))
print(ex, end=' ')
for i in range(1, num):
	print(round(a[i][0] / ex), end=' ')


n = int(input())
a = list(map(int, input().split(' ')))
b = list(map(int, input().split(' ')))
ABC = round((a[1] * a[2] * b[2]) ** 0.5)
A = ABC // b[2]
ans = [A]
for i in range(1, n):
	ans.append(a[i] // A)
print(' '.join(map(str, ans)))


import math
n = int(input())
grid = []
for i in range(n):
	stuff = input()
	row = [int(cell) for cell in stuff.split()]
	grid.append(row)
tmp = grid[0][1] * grid[0][2] * grid[1][2]
sqrt_tmp = int(math.sqrt(tmp))
a = []
a.append(sqrt_tmp // grid[1][2])
for i in range(1, n):
	a.append(grid[0][i] // a[0])
res = str(a[0])
for i in range(1, n):
	res += ' %s' % str(a[i])
print(res)


def ceil(a, b):
	if a % b == 0:
		return a // b
	return a // b + 1
n = int(input())
a = [list(map(int, input().split())) for _ in range(n)]
b = [0 for _ in range(n)]
for i in range(n - 2):
	b[i] = ceil(a[i][i + 1] * a[i][i + 2], a[i + 1][i + 2])
	b[i] = int(b[i] ** 0.5)
b[n - 1] = ceil(a[n - 1][n - 2] * a[n - 1][n - 3], a[n - 2][n - 3])
b[n - 1] = int(b[n - 1] ** 0.5)
b[n - 2] = ceil(a[n - 1][n - 2], b[n - 1])
print(*b)


def main():
	n = int(input())
	prods = []
	ans = []
	matrix = []
	for i in range(n):
		matrix.append(list(map(int, input().split())))
	p1 = matrix[n - 2][n - 1]
	p2 = matrix[n - 3][n - 2]
	p3 = matrix[n - 3][n - 1]
	an = int((p1 * p3 // p2) ** 0.5)
	ans.append(an)
	for i in range(n - 2, -1, -1):
		ai = matrix[i][i + 1] // ans[-1]
		ans.append(ai)
	ans.reverse()
	for i in ans:
		print(i, end=' ')
main()


from math import sqrt
n = int(input())
arr = []
for i in range(n):
	arr.append([int(s) for s in input().split()])
i = 0
j = 1
ans = []
ans.append(sqrt(arr[2][0] * arr[0][1] // arr[2][1]))
ans.append(sqrt(arr[2][1] * arr[1][0] // arr[2][0]))
for k in range(2, n):
	lis = []
	ans.append(sqrt(arr[i][k] * arr[j][k] // arr[i][j]))
ans = [int(i) for i in ans]
print(*ans)


import math
n = int(input())
arr = []
for i in range(n):
	arr.append(list(map(int, input().split())))
ans = []
for i in range(n):
	if i == 0:
		temp = arr[i][1] * arr[i][2] // arr[2][1]
		ans.append(int(temp ** 0.5))
	elif i == 1:
		temp = arr[i][0] * arr[i][2] // arr[2][0]
		ans.append(int(temp ** 0.5))
	else:
		temp = arr[i][0] * arr[i][1] // arr[1][0]
		ans.append(int(temp ** 0.5))
for i in ans:
	print(i, end=' ')


n = int(input())
a = []
ans = [0] * n
for i in range(n):
	a.append(list(map(int, input().split())))
if n == 1:
	print(1)
elif n == 2:
	print(1, a[0][1])
else:
	ans[2] = (a[1][2] * a[0][2] // a[0][1]) ** 0.5
	ans[0] = int(a[0][2] // ans[2])
	for i in range(1, n):
		ans[i] = int(a[0][i] // ans[0])
	print(*ans, sep=' ')


n = int(input())
d = []
for i in range(n):
	d.append([int(j) for j in input().split()])
x2 = d[1][0] * d[2][0] // d[2][1]
ans = [0] * n
ans[0] = int(x2 ** 0.5 + 0.5)
for i in range(1, n):
	ans[i] = d[0][i] // ans[0]
for j in ans:
	print(j, end=' ')
print()


import math
n = int(input())
arr = []
for i in range(n):
	ar = list(map(int, input().split()))
	arr.append(ar)
l = []
a = int(math.sqrt(arr[0][1] * arr[0][2] / arr[1][2]))
l.append(a)
i = 2
while i <= n:
	l.append(arr[i - 1][i - 2] // l[-1])
	i += 1
for e in l:
	print(e, end=' ')


from math import sqrt
n = int(input())
s = [int(x) for x in input().split()]
s2 = [int(x) for x in input().split()]
ab = s[1]
ac = s[2]
bc = s2[2]
a = int(sqrt(ab * ac // bc))
print(a, end=' ')
for x in s[1:]:
	print(x // a, end=' ')
print()


from math import gcd
n = int(input())
a = [list(map(int, input().split())) for i in range(n)]
b = [0] * n
u = int((a[0][1] * a[0][2] // a[1][2]) ** 0.5 + 0.0001)
b[0] = u
for i in range(1, n):
	b[i] = a[0][i] // u
print(*b)


import math
from collections import deque, defaultdict
from sys import stdin, stdout
input = stdin.readline
listin = lambda : list(map(int, input().split()))
mapin = lambda : map(int, input().split())
n = int(input())
z = []
for i in range(n):
	z.append(listin())
first = z[0][1] * z[0][2] // z[1][2]
first = int(first ** 0.5)
a = [first]
for i in range(1, n):
	a.append(z[0][i] // a[0])
print(*a)


import sys
from collections import defaultdict, deque
from math import sqrt, gcd

def input():
	return sys.stdin.readline()[:-1]
n = int(input())
a = []
for _ in range(n):
	a.append([int(x) for x in input().split()])
b = int(sqrt(a[1][0] * a[2][1] // a[2][0]))
ans = [0] * n
for (i, e) in enumerate(a[1]):
	ans[i] = b
	if e:
		ans[i] = e // b
print(*ans)


n = int(input())
m = [list(map(int, input().split())) for i in range(n)]

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)
g = m[0][1]
for i in range(2, n):
	g = gcd(g, m[0][i])
b = [m[0][i] / g for i in range(1, n)]
import math
kw = math.sqrt(m[1][2] / (b[0] * b[1]))
c = [b[i] * kw for i in range(n - 1)]
a0 = m[0][1] / c[0]
c = [a0] + c
for i in c:
	print(int(i), end=' ')


import sys

def sqrt(s):
	r = 0
	m = 2147483648
	while m > 0:
		if (r | m) * (r | m) <= s:
			r |= m
		m >>= 1
	return r
n = int(sys.stdin.readline().strip())
m = []
for _ in range(n):
	m.append([int(_) for _ in sys.stdin.readline().strip().split()])
r = []
for i in range(n):
	j1 = (i + 1) % n
	j2 = (i + 2) % n
	r.append(sqrt(m[i][j1] * m[i][j2] // m[j1][j2]))
sys.stdout.write(' '.join([str(_) for _ in r]) + '\n')


n = int(input())
m = []
for i in range(n):
	m.append(list(map(int, input().split(' '))))
a = [0] * n
for i in range(n - 2):
	a[i] = round(m[i + 1][i] * m[i + 2][i] / m[i + 1][i + 2])
a[n - 2] = round(m[n - 1][n - 2] * m[n - 3][n - 2] / m[n - 1][n - 3])
a[n - 1] = round(m[n - 2][n - 1] * m[n - 3][n - 1] / m[n - 2][n - 3])
for i in range(n):
	print(round(a[i] ** 0.5), end=' ')


ara = []
n = int(input())
for i in range(0, n):
	s = input()
	List = []
	for j in s.split():
		List.append(int(j))
	ara.append(List)
mul = int(ara[0][1] * ara[0][2] / ara[1][2])
mul = int(mul ** 0.5)
print(mul, end=' ')
for i in range(1, n):
	print(int(ara[0][i] / mul), end=' ')
print()


def nod(a, b):
	while a != 0 and b != 0:
		if a > b:
			a %= b
		else:
			b %= a
	gcd = a + b
	return gcd
n = int(input())
m = [0] * n
pred = [0] * n
for i in range(n):
	m[i] = input().split(' ')
	for j in range(n):
		m[i][j] = int(m[i][j])
while True:
	gcd = nod(m[0][1], m[0][2])
	for i in range(3, n):
		gcd = nod(m[0][i], gcd)
	pred[0] = gcd
	for i in range(1, n):
		pred[i] = int(m[0][i] / gcd)
	flag = 0
	for i in range(n):
		for j in range(n):
			if i != j:
				if pred[i] * pred[j] != m[i][j]:
					flag = 1
					break
		if flag:
			d = int(int(m[1][2] / (pred[1] * pred[2])) ** 0.5)
			pred[0] = int(pred[0] / d)
			for i in range(1, n):
				pred[i] = pred[i] * d
	break
answer = ''
for i in range(n):
	answer += str(pred[i]) + ' '
answer = answer[:-1]
print(answer)


import math
size = int(input())
mat = []
for i in range(size):
	val = list(map(int, input().split(' ')))
	mat.append(val)
diag = []
for i in range(1, size):
	diag.append(mat[0][i])
x = mat[1][2] / diag[0]
y = math.sqrt(diag[1] / x)
diag.insert(0, int(y))
for i in range(1, len(diag)):
	diag[i] = int(diag[i] // y)
print(*diag)


n = int(input())
table = []
for i in range(n):
	table.append([int(x) for x in input().split()])
for i in range(n):
	if i + 2 >= n:
		print(round((table[i][i - 1] / table[i - 1][i - 2] * table[i][i - 2]) ** 0.5), end='')
	else:
		print(round((table[i][i + 1] / table[i + 1][i + 2] * table[i][i + 2]) ** 0.5), end='')
	if i != n - 1:
		print(' ', end='')
	else:
		print('\n', end='')


n = int(input())
M = []
for i in range(n):
	M += [list(map(int, input().split()))]
arr = []
for k in range(n // 2):
	arr += [int((M[k][k + 1] * M[k][k + 2] / M[k + 1][k + 2]) ** 0.5)]
for k in range(n // 2, n):
	arr += [int((M[k][k - 1] * M[k][k - 2] / M[k - 1][k - 2]) ** 0.5)]
print(*arr)


import math
n = int(input())
mat = []
for i in range(n):
	val = list(map(int, input().split(' ')))
	mat.append(val)
d = []
for i in range(1, n):
	d.append(mat[0][i])
y = math.sqrt(d[1] / (mat[1][2] / d[0]))
d.insert(0, int(y))
for i in range(1, len(d)):
	d[i] = int(d[i] // y)
print(*d)


n = int(input())
from math import gcd, sqrt
m = [1 for i in range(n)]
l = [[] for i in range(n)]
for i in range(n):
	l[i] = [int(j) for (ct, j) in enumerate(input().split())]
val = l[n - 2][-1]
prod = 1
for i in range(1, 3):
	prod *= l[n - 3][n - 3 + i]
m[n - 3] = int((prod / val) ** 0.5)
for i in range(1, 3):
	m[n - 3 + i] = l[n - 3][n - 3 + i] // m[n - 3]
for i in range(n - 3, -1, -1):
	m[i] = l[i][i + 1] // m[i + 1]
for i in range(n):
	print(m[i], end=' ')
print()


n = int(input())
l = []
for i in range(n):
	l.append(list(map(int, input().split())))
if n >= 3:
	a2 = (l[0][1] * l[1][2] / l[0][2]) ** 0.5
	ans = []
	for i in range(n):
		if i == 1:
			ans.append(a2)
		else:
			ans.append(l[1][i] / a2)
	for i in range(n):
		print(int(ans[i]), end=' ')
elif n == 2:
	print(1, l[0][1])
else:
	print(1, 1)


import math
n = int(input())
a = []
for i in range(0, n):
	a.append(list(map(int, input().rstrip().split())))
res = []
res.append(math.floor(math.sqrt(a[0][1] * a[0][2] // a[1][2])))
for i in range(1, n):
	res.append(math.floor(a[i][0] / res[0]))
for i in range(0, n):
	print(res[i], end=' ')


n = int(input())
matrix = [[int(i) for i in input().split()] for i in range(n)]
src = []
for i in range(n):
	value = (matrix[i - 1][i] * matrix[(i + 1) % n][i] / matrix[i - 1][(i + 1) % n]) ** 0.5
	src.append(int(value))
print(*src)


import sys
import os
from io import IOBase, BytesIO

def main():
	n = int(input())
	arr = [0] * n
	for i in range(n):
		arr[i] = get_array()
	x = arr[1][0] * arr[2][0] // arr[2][1]
	from math import sqrt
	ans = int(sqrt(x))
	print(ans, end=' ')
	for i in range(1, n):
		p = arr[i][0] // ans
		print(p, end=' ')
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		py2 = round(0.5)
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2 == 1:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def get_array():
	return list(map(int, sys.stdin.readline().split()))

def get_ints():
	return map(int, sys.stdin.readline().split())

def input():
	return sys.stdin.readline().strip()
main()


import math
n = int(input())
arr = [[None for x in range(n)] for x in range(n)]
for i in range(n):
	arr[i] = list(map(int, input().split()))
s = int(math.sqrt(arr[0][1] * arr[0][2] / arr[1][2]))
print(s, end=' ')
for j in range(1, n):
	print(int(arr[j][0] / s), end=' ')


import math
n = int(input())
l = []
for i in range(n):
	lst = list(map(int, input().strip().split(' ')))
	l.append(lst)
if n == 1:
	print(1)
elif n == 2:
	print(1, l[0][1], end=' ')
else:
	k = int(math.sqrt(l[0][1] * l[0][2] * l[1][2]) // l[1][2])
	for j in range(n):
		if j == 0:
			print(k, end=' ')
		else:
			print(l[0][j] // k, end=' ')


import sys
import math
input = sys.stdin.readline
n = int(input())
mat = []
for i in range(n):
	mat.append(list(map(int, input().split())))
g = mat[0][1]
for i in range(1, n):
	g = math.gcd(g, mat[0][i])
ans = [g]
for i in range(1, n):
	ans.append(mat[0][i] // g)
if n == 2:
	print(*ans)
	exit()
if ans[1] * ans[2] != mat[1][2]:
	diff = mat[1][2] // (ans[1] * ans[2])
	diff = int(diff ** 0.5)
	g = g // diff
	ans = [g]
	for i in range(1, n):
		ans.append(mat[0][i] // g)
	print(*ans)
else:
	print(*ans)


import math
n = int(input())
m = []
for _ in range(n):
	m.append([int(i) for i in input().split(' ')])
a = [0] * n
for i in range(n):
	j = (i + 1) % n
	k = (i + 2) % n
	a[i] = math.sqrt(m[i][k] * m[j][i] / m[j][k])
print(' '.join([str(int(i)) for i in a]))


n = int(input())
p = []
for i in range(n):
	q = []
	q = list(map(int, input().split()))
	p.append(q)
a = 0
r = []
a2 = int((p[0][2] * p[1][2] / p[0][1]) ** (1 / 2))
for j in range(1, n):
	if j != 2:
		a = int(p[0][j] * a2 / p[0][2])
		r.append(a)
a0 = int(p[0][1] / r[0])
print(a0, end=' ')
print(r[0], end=' ')
print(a2, end=' ')
for i in range(0, n - 3):
	print(r[i + 1], end=' ')


n = int(input())
arr = [[int(i) for i in input().split()] for j in range(n)]
ans = []
k = arr[1][2] / arr[0][2]
p = round((arr[1][0] / k) ** 0.5)
ans.append(p)
for i in range(1, n):
	ans.append(round(arr[i][0] / p))
for _ in ans:
	print(_, end=' ')


input = __import__('sys').stdin.readline
n = int(input())
l = [None] + [[0] + [*map(int, input().split())] for _ in range(n)]
s = set()
i = 1
while i * i <= l[1][2]:
	if l[1][2] % i == 0:
		s.add(i)
		s.add(l[1][2] // i)
	i += 1
a = [0] * (n + 1)
for i in s:
	a[1] = i
	ok = True
	for j in range(2, n + 1):
		if l[1][j] % a[1]:
			ok = False
			break
		a[j] = l[1][j] // a[1]
	if not ok:
		continue
	for y in range(1, n + 1):
		for x in range(y + 1, n + 1):
			if a[y] * a[x] != l[y][x]:
				ok = False
	if not ok:
		continue
	for j in range(1, n + 1):
		print(a[j], end=' ')
	exit()


N = int(input())
items = []
for i in range(N):
	items.append(tuple(map(int, input().split())))
import math
a1 = int(math.sqrt(items[0][1] * items[0][2] // items[1][2]))
ans = [a1]
for i in range(1, N):
	ans.append(items[0][i] // a1)
for a in ans:
	print(a, end=' ')
print()


n = int(input())
s = []
for i in range(n):
	l = [*map(int, input().split())]
	s.append(l)
a = s[0]
a[0] = s[0][1] * s[0][2] / s[1][2]
print(*(int(i / a[0] ** 0.5) for i in a))


from math import sqrt, floor
n = int(input())
m = []
for i in range(n):
	m.append(list(map(int, input().split())))
arr = []
for i in range(n - 2):
	x = m[i][i + 1] * m[i][i + 2] // m[i + 1][i + 2]
	arr.append(floor(sqrt(x)))
for i in range(n - 2, n):
	x = m[i][i - 1] * m[i][i - 2] // m[i - 1][i - 2]
	arr.append(floor(sqrt(x)))
print(*arr)


n = int(input())
s = [[0] * n] * n
a = [0] * (n + 1)
for i in range(0, n):
	s[i] = list(map(int, input().split()))
a[1] = int((s[0][1] * s[0][2] // s[1][2]) ** (1 / 2))
for i in range(1, n):
	a[i + 1] = s[0][i] // a[1]
for z in range(1, n + 1):
	print(a[z], end=' ')


import math
n = int(input())
arr = []
for i in range(n):
	temparr = [int(j) for j in input().split()]
	arr.append(temparr)
a = arr[0][1]
b = arr[0][2]
c = arr[1][2]
final = int(math.sqrt(a * b // c))
print(final, end=' ')
for i in range(1, n):
	print(arr[0][i] // final, end=' ')


import math
a = int(input())
mass = [[int(j) for j in input().split()] for i in range(a)]
am = [0] * a
for j in range(a):
	(q1, q2) = (-1, -1)
	for i in range(a):
		if j != i:
			if q1 == -1:
				q1 = i
			elif q2 == -1:
				q2 = i
				break
	am[j] = int(math.sqrt(mass[j][q2] * mass[j][q1] // mass[q1][q2]))
print(*am)


from math import *
n = int(input())
a = []
for i in range(n):
	a.append(list(map(int, input().split())))
(a1, b1, c1) = (a[0][1], a[1][2], a[2][0])
x = ceil(sqrt(a1 * c1 // b1))
print(x, end=' ')
for i in range(1, n):
	print(a[0][i] // x, end=' ')


from sys import stdin, stdout
import heapq
import cProfile, math
from collections import Counter, defaultdict, deque
from bisect import bisect_left, bisect, bisect_right
import itertools
from copy import deepcopy
from fractions import Fraction
import sys, threading
import operator as op
from functools import reduce
import sys
sys.setrecursionlimit(10 ** 6)
threading.stack_size(2 ** 27)
fac_warm_up = False
printHeap = str()
memory_constrained = False
P = 10 ** 9 + 7

class MergeFind:

	def __init__(self, n):
		self.parent = list(range(n))
		self.size = [1] * n
		self.num_sets = n
		self.lista = [[_] for _ in range(n)]

	def find(self, a):
		to_update = []
		while a != self.parent[a]:
			to_update.append(a)
			a = self.parent[a]
		for b in to_update:
			self.parent[b] = a
		return self.parent[a]

	def merge(self, a, b):
		a = self.find(a)
		b = self.find(b)
		if a == b:
			return
		if self.size[a] < self.size[b]:
			(a, b) = (b, a)
		self.num_sets -= 1
		self.parent[b] = a
		self.size[a] += self.size[b]
		self.lista[a] += self.lista[b]

	def set_size(self, a):
		return self.size[self.find(a)]

	def __len__(self):
		return self.num_sets

def display(string_to_print):
	stdout.write(str(string_to_print) + '\n')

def prime_factors(n):
	factors = dict()
	for i in range(2, math.ceil(math.sqrt(n)) + 1):
		while n % i == 0:
			if i in factors:
				factors[i] += 1
			else:
				factors[i] = 1
			n = n // i
	if n > 2:
		factors[n] = 1
	return factors

def all_factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

def fibonacci_modP(n, MOD):
	if n < 2:
		return 1
	return (cached_fn(fibonacci_modP, (n + 1) // 2, MOD) * cached_fn(fibonacci_modP, n // 2, MOD) + cached_fn(fibonacci_modP, (n - 1) // 2, MOD) * cached_fn(fibonacci_modP, (n - 2) // 2, MOD)) % MOD

def factorial_modP_Wilson(n, p):
	if p <= n:
		return 0
	res = p - 1
	for i in range(n + 1, p):
		res = res * cached_fn(InverseEuler, i, p) % p
	return res

def binary(n, digits=20):
	b = bin(n)[2:]
	b = '0' * (digits - len(b)) + b
	return b

def is_prime(n):
	if n < 4:
		return True
	if n % 2 == 0:
		return False
	if n % 3 == 0:
		return False
	i = 5
	w = 2
	while i * i <= n:
		if n % i == 0:
			return False
		i += w
		w = 6 - w
	return True

def generate_primes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 1
	return prime
factorial_modP = []

def warm_up_fac(MOD):
	global factorial_modP, fac_warm_up
	if fac_warm_up:
		return
	factorial_modP = [1 for _ in range(fac_warm_up_size + 1)]
	for i in range(2, fac_warm_up_size):
		factorial_modP[i] = factorial_modP[i - 1] * i % MOD
	fac_warm_up = True

def InverseEuler(n, MOD):
	return pow(n, MOD - 2, MOD)

def nCr(n, r, MOD):
	global fac_warm_up, factorial_modP
	if not fac_warm_up:
		warm_up_fac(MOD)
		fac_warm_up = True
	return factorial_modP[n] * (pow(factorial_modP[r], MOD - 2, MOD) * pow(factorial_modP[n - r], MOD - 2, MOD) % MOD) % MOD

def test_print(*args):
	if testingMode:
		print(args)

def display_list(list1, sep=' '):
	stdout.write(sep.join(map(str, list1)) + '\n')

def display_2D_list(li):
	for i in li:
		print(i)

def prefix_sum(li):
	sm = 0
	res = []
	for i in li:
		sm += i
		res.append(sm)
	return res

def get_int():
	return int(stdin.readline().strip())

def get_tuple():
	return map(int, stdin.readline().split())

def get_list():
	return list(map(int, stdin.readline().split()))
memory = dict()

def clear_cache():
	global memory
	memory = dict()

def cached_fn(fn, *args):
	global memory
	if args in memory:
		return memory[args]
	else:
		result = fn(*args)
		memory[args] = result
		return result

def ncr(n, r):
	return math.factorial(n) / (math.factorial(n - r) * math.factorial(r))

def binary_search(i, li):
	fn = lambda x: li[x] - x // i
	x = -1
	b = len(li)
	while b >= 1:
		while b + x < len(li) and fn(b + x) > 0:
			x += b
		b = b // 2
	return x
TestCases = False
fac_warm_up_size = 10 ** 5 + 100
optimise_for_recursion = False

def main():
	n = get_int()
	mat = []
	for _ in range(n):
		mat.append(get_list())
	a11 = mat[0][2] * mat[0][1] // mat[1][2]
	a11 = int(a11 ** 0.5)
	res = [a11]
	for i in range(1, n):
		res.append(mat[0][i] // a11)
	display_list(res)
if TestCases:
	for i in range(get_int()):
		main()
else:
	main() if not optimise_for_recursion else threading.Thread(target=main).start()


from math import sqrt
n = int(input())
A = []
for i in range(n):
	A.append(list(map(int, input().split())))
ans = [0 for i in range(n)]
for i in range(n):
	x = A[i][(i + 1) % n] * A[(i + 1) % n][(i + 2) % n]
	x = x // A[i][(i + 2) % n]
	ans[(i + 1) % n] = int(sqrt(x))
print(*ans)


n = int(input())
x = []
for i in range(n):
	a = list(map(int, input().split()))
	x.append(a)
an = (x[n - 2][n - 1] / (x[n - 2][0] / x[n - 1][0])) ** 0.5
a1 = x[n - 1][0] // an
y = []
for i in x[0]:
	y.append(i // int(a1))
y[0] = int(a1)
print(*y, sep=' ')


import math
n = int(input())
M = [0] * n
for i in range(n):
	M[i] = input().split(' ')
M[0][1] = int(M[0][1])
M[0][2] = int(M[0][2])
M[1][2] = int(M[1][2])
a1 = math.sqrt(M[0][1] * M[0][2] / M[1][2])
ans = [0] * n
ans[0] = int(a1)
for j in range(1, n):
	ans[j] = int(M[0][j]) / a1
	ans[j] = int(ans[j])
arr = ''
for y in range(n - 1):
	arr += str(ans[y])
	arr += ' '
arr += str(ans[n - 1])
print(arr)


a = int(input())
l = []
for i in range(a):
	l.append(list(map(int, input().split())))
ans = []
if a >= 3:
	x = l[0][1]
	x1 = l[1][2]
	x2 = l[2][0]
	ans.append(round((x * x2 / x1) ** 0.5))
for i in l[0][1:]:
	ans.append(i // ans[0])
print(*ans)


from math import sqrt
n = int(input())
a = []
for _ in range(n):
	a.append([int(i) for i in input().split()])
r = []
q = int(sqrt(a[0][1] * a[1][2] // a[0][2]))
r.append(a[0][1] // q)
r.append(q)
k = 1
for i in range(2, n):
	r.append(a[i - 1][i] // r[-1])
print(' '.join([str(x) for x in r]))


import math
n = int(input())
new = []
for i in range(n):
	new.append(list(map(int, input().split())))
ans = [0 for i in range(n)]
for i in range(n):
	for j in range(n - 1):
		if i != j and i != 1:
			ans[i] = int(math.sqrt(new[i][j] * new[i][j + 1] / new[j][j + 1]))
			break
		elif i == 1 and i != j:
			ans[i] = int(math.sqrt(new[i][j] * new[i][j + 2] / new[j][j + 2]))
			break
print(*ans)


import math
n = int(input())
a = [[int(i) for i in input().split()] for j in range(n)]
ans = []
b = math.sqrt(a[0][1] * a[1][2] / a[0][2])
b = int(b)
ans.append(int(a[0][1] / b))
ans.append(b)
ans.append(int(a[1][2] / b))
for i in range(3, n, 2):
	if i + 1 < n:
		b = ans[-1]
		b = int(a[i - 1][i] / b)
		ans.append(b)
		ans.append(int(a[i][i + 1] / b))
	elif i < n:
		b = ans[-1]
		ans.append(int(a[i - 1][i] / b))
print(*ans)


N = int(input())
M = []
for i in range(N):
	M.append(list(map(int, input().split())))
ans = [0]
ans[0] = int((M[0][2] * M[0][1] // M[1][2]) ** (1 / 2))
for i in range(1, N):
	ans.append(M[0][i] // ans[0])
for a in ans:
	print(a, end=' ')


from math import sqrt
n = int(input())
m = []
for i in range(n):
	s = input()
	m.append(s.split())
a = [0 for i in range(n)]
for i in range(n):
	a[i] = int(m[i % n][(i + 2) % n]) * int(m[i % n][(i + 1) % n]) // int(m[(i + 1) % n][(i + 2) % n])
b = [str(int(sqrt(int(i)))) for i in a]
print(' '.join(b))


n = int(input())
m = []
for i in range(n):
	s = list(map(int, input().split()))
	m.append(s)
a = []
from math import sqrt
s = m[0][1] * m[0][2] * m[1][2]
s = int(sqrt(s) + 0.0001)
a1 = s // m[1][2]
a2 = s // m[0][2]
a3 = s // m[0][1]
a = [a1, a2, a3]
for i in range(3, n):
	z = m[0][i] // a1
	a.append(z)
print(*a)


n = int(input())
M = list()
for i in range(n):
	M.append(list(map(int, input().split())))
A = []
for i in range(n):
	if i == 0:
		x = M[i][1] * M[i][2] / M[1][2]
	elif i == n - 1:
		x = M[i][0] * M[i][1] / M[0][1]
	else:
		x = M[i][i - 1] * M[i][i + 1] / M[i - 1][i + 1]
	A.append(int(x ** 0.5))
finalAns = ''
for x in A:
	finalAns += str(x) + ' '
print(finalAns)


import math
n = int(input())
l = []
for i in range(n):
	l.append(list(map(int, input().split())))
x = l[0][1]
y = l[0][2]
z = l[1][2]
a2 = math.sqrt(x * z // y)
a1 = x // a2
a3 = z // a2
print(int(a1), int(a2), int(a3), end=' ')
for j in range(n - 3):
	print(int(l[0][j + 3] // a1), end=' ')
print()


from math import sqrt
n = int(input())
a = [0] * n
ans = [0] * n
for i in range(n):
	a[i] = [int(x) for x in input().split()]
ans[2] = sqrt(a[2][1] * a[2][0] / a[1][0])
ans[1] = a[2][1] / ans[2]
ans[0] = a[0][1] / ans[1]
for i in range(3, n):
	ans[i] = a[i][0] / ans[0]
for i in range(n):
	print(int(ans[i]), end=' ')


import sys
readline = sys.stdin.readline

def gcd(m, n):
	while n:
		(m, n) = (n, m % n)
	return m
N = int(readline())
A = [list(map(int, readline().split())) for i in range(N)]
A0 = A[0]
A1 = A[1]
A2 = A[2]
g = A0[1]
for i in range(2, N):
	g = gcd(g, A0[i])

def chk(x):
	B = [A0[i] // x for i in range(N)]
	B[0] = x
	b1 = B[1]
	b2 = B[2]
	return all((A1[j] == b1 * B[j] for j in range(2, N))) and all((A2[j] == b2 * B[j] for j in range(3, N)))
x = 1
y = -1
while x * x <= g:
	if g % x > 0:
		x += 1
		continue
	if chk(x):
		y = x
		break
	if chk(g // x):
		y = g // x
		break
	x += 1
B = [A0[i] // y for i in range(N)]
B[0] = y
print(*B)


from math import sqrt
n = int(input())
array = []
for i in range(n):
	array.append(list(map(int, input().split())))
third = int(sqrt(array[0][2] * array[1][2] / array[0][1]))
x = int(array[0][2] / third)
print(x, int(array[0][1] / x), third, end=' ')
for i in range(3, n):
	print(int(sqrt(array[i - 2][i] * array[i - 1][i] / array[i - 2][i - 1])), end=' ')


import math
n = int(input())
arr = []
for i in range(n):
	inp = [int(x) for x in input().split()]
	arr.append(inp)
j = 1
for i in range(len(arr) - 2):
	x = arr[i][j]
	y = arr[i][j + 1]
	z = arr[i + 1][j + 1]
	n1 = int(math.sqrt(x * y // z))
	n2 = int(math.sqrt(x * z // y))
	n3 = int(math.sqrt(y * z // x))
	j += 1
	if i == 0:
		print(n1, n2, n3, sep=' ', end=' ')
	else:
		print(n3, end=' ')


from bisect import *
from math import *
from collections import Counter, defaultdict
from sys import stdin, stdout
input = stdin.readline
I = lambda : int(input())
M = lambda : map(int, input().split())
LI = lambda : list(map(int, input().split()))
for _ in range(1):
	n = I()
	a = []
	for i in range(n):
		b = LI()
		a += [b]
	c = []
	b = 0
	c += [int(sqrt(a[b][b + 1] * a[b][b + 2] / a[b + 1][b + 2]))]
	for i in range(1, n):
		c += [a[0][i] // c[0]]
	print(*c)


import math
n = int(input())
x = []
a = []
for i in range(0, n):
	x = list(map(int, input().split()))
	a.append(x)
a2 = int(a[0][1] * a[0][2] / a[1][2])
f = int(math.sqrt(a2))
ans = []
ans.append(f)
for i in range(1, n):
	ans.append(int(a[0][i] / f))
print(*ans)


n = int(input())
a = []
o = []
for i in range(n):
	A = [int(i) for i in input().split()]
	a.append(A)
k1 = (a[0][1] * a[0][2] / a[1][2]) ** 0.5
o.append(int(k1))
for i in range(1, n):
	o.append(int(a[0][i] // k1))
for i in o:
	print(i, end=' ')


q = int(input())
w = [list(map(int, input().split())) for j in range(q)]
r = []
import math
e = math.sqrt(w[0][1] * w[0][2] // w[1][2])
t = e
for i in range(q):
	r.append(str(int(t)))
	if i == q - 1:
		break
	t = w[i][i + 1] // t
print(' '.join(r))


n = int(input())
l = []
for i in range(0, n):
	o = list(map(int, input().split()))
	l.append(o)
m = []
m.append(int((l[0][1] * l[0][2] // l[1][2]) ** 0.5))
m.append(int((l[1][2] * l[1][0] // l[2][0]) ** 0.5))
m.append(int((l[1][2] * l[2][0] // l[1][0]) ** 0.5))
for i in range(3, n):
	m.append(int((l[1][i] * l[i][0] // l[1][0]) ** 0.5))
print(*m)


import math

def fact(a, b):
	ans = 1
	for i in range(a, b + 1):
		ans *= i
	return str(ans) - 1

def comb(n, c):
	return fact(n) // (fact(n - c) * c)
n = int(input())
nums = []
for i in range(n):
	nums.append(list(map(int, input().split())))
a = int(math.sqrt(nums[0][1] * nums[0][2] // nums[1][2]))
ans = [str(a)]
for i in range(1, n):
	ans.append(str(int(nums[i][0] // a)))
print(' '.join(ans))


from bisect import *
from collections import *
from itertools import *
import functools
import sys
import math
from decimal import *
from copy import *
from heapq import *
getcontext().prec = 30
MAX = sys.maxsize
MAXN = 10 ** 6 + 1
MOD = 10 ** 9 + 7

def isprime(n):
	n = abs(int(n))
	if n < 2:
		return False
	if n == 2:
		return True
	if not n & 1:
		return False
	for x in range(3, int(n ** 0.5) + 1, 2):
		if n % x == 0:
			return False
	return True

def mhd(a, b):
	return abs(a[0] - b[0]) + abs(b[1] - a[1])

def charIN(x=' '):
	return sys.stdin.readline().strip().split(x)

def arrIN(x=' '):
	return list(map(int, sys.stdin.readline().strip().split(x)))

def eld(x, y):
	a = y[0] - x[0]
	b = x[1] - y[1]
	return (a * a + b * b) ** 0.5

def lgcd(a):
	g = a[0]
	for i in range(1, len(a)):
		g = math.gcd(g, a[i])
	return g

def ms(a):
	msf = -MAX
	meh = 0
	st = en = be = 0
	for i in range(len(a)):
		meh += a[i]
		if msf < meh:
			msf = meh
			st = be
			en = i
		if meh < 0:
			meh = 0
			be = i + 1
	return (msf, st, en)

def ncr(n, r):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % MOD
		den = den * (i + 1) % MOD
	return num * pow(den, MOD - 2, MOD) % MOD

def flush():
	return sys.stdout.flush()

def fac(n):
	ans = 1
	for i in range(1, n + 1):
		ans *= i
		ans %= MOD
	return ans
n = int(input())
l = []
for _ in range(n):
	l.append(arrIN())
a = l[0][1]
b = l[0][2]
c = l[1][2]
x = int((a * b / c) ** 0.5)
ans = [x]
for i in range(1, n):
	ans.append(l[0][i] // x)
print(*ans)


import math
n = int(input())
mat = []
for i in range(n):
	l = input()
	l = l.split(' ')
	for i in range(n):
		l[i] = int(l[i])
	mat.append(l)
val1 = mat[0][2]
val2 = mat[1][2]
a1 = 1
a2 = 1
if val1 >= val2:
	t = mat[0][1] * val2 / val1
	a2 = int(math.sqrt(t))
	a1 = val1 * a2 / val2
else:
	t = mat[0][1] * val1 / val2
	a1 = int(math.sqrt(t))
	a2 = val2 * a1 / val1
res = []
res.append(a1)
for i in range(1, n):
	res.append(mat[0][i] / a1)
for i in range(n):
	print(int(res[i]), end=' ')


import math
n = int(input())
prod = [[int(tok) for tok in input().split()] for _ in range(n)]
prod3 = int(math.sqrt(prod[0][1] * prod[0][2] * prod[1][2]))
first = prod3 // prod[1][2]
print(first, end=' ')
for i in range(1, n):
	print(prod[0][i] // first, end=' ')
print()


import math
m = int(input())
a = [[] for i in range(m)]
for i in range(m):
	line = input().split(' ')
	for j in range(len(line)):
		a[i].append(int(line[j]))
a1 = int(math.sqrt(a[0][1] * a[0][2] / a[1][2]))
c = []
c.append(a1)
for i in range(1, m):
	b = int(a[0][i] / a1)
	c.append(b)
print(*c)


import math
a = int(input())
ls = []
for i in range(a):
	temp = [int(i) for i in input().strip().split()]
	ls.append(temp)
a1 = int(math.sqrt(ls[1][0] * ls[2][0] // ls[2][1]))
ans = []
ans.append(a1)
for i in range(1, a):
	temp = ls[i][0] // a1
	ans.append(temp)
for i in ans:
	print(i, end=' ')


n = int(input())
s0 = list(map(int, input().split()))
s1 = list(map(int, input().split()))
a = s0[1]
b = s0[2]
c = s1[2]
x1 = int((a * b // c) ** 0.5)
print(x1, *map(lambda x: x // x1, s0[1:]))


from math import sqrt

def divis(a):
	A = [1, a]
	for i in range(2, round(sqrt(a) + 1)):
		if a % i == 0:
			A.append(i)
			if i ** 2 != a:
				A.append(a // i)
	return sorted(A)

def check(x):
	B = [x]
	for j in range(n):
		if A[0][j] != 0:
			B.append(A[0][j] // x)
	for i in range(1, n):
		for j in range(n):
			if A[i][j] != 0:
				if A[i][j] != B[i] * B[j]:
					return (False, [])
	return (True, B)
n = int(input())
A = []
for i in range(n):
	A.append(list(map(int, input().split())))
Div = divis(A[0][1])
for i in range(len(Div)):
	(res, C) = check(Div[i])
	if res:
		print(*C)
		break


from sys import stdin, stdout
n = int(stdin.readline())
a = []
for i in range(0, n):
	l = [int(x) for x in stdin.readline().split()]
	a.append(l)
y_z = a[0][1] / a[0][2]
z = int((a[1][2] / y_z) ** 0.5)
x = a[0][2] // z
print(x, end=' ')
for i in range(1, n):
	print(a[0][i] // x, end=' ')


import sys
input = sys.stdin.readline
N = int(input())
M = [list(map(int, input().split())) for _ in range(N)]
x = M[0][1]
y = M[1][2]
z = M[2][0]
ans = [None] * N
T = y * z // x
c = int(T ** 0.5)
C = [c - 1, c, c + 1, c + 2]
for p in C:
	if p * p == T:
		ans[2] = p
		break
ans[0] = z // ans[2]
ans[1] = y // ans[2]
for n in range(3, N):
	ans[n] = M[0][n] // ans[0]
print(*ans)


n = int(input())
array = []
for i in range(n):
	row = list(map(int, input().strip().split()))
	array.append(row)
a1 = int((array[0][1] * array[0][2] / array[1][2]) ** 0.5)
ans = [str(a1)]
for i in range(1, n):
	this = int(array[0][i] / a1)
	ans.append(str(this))
print(' '.join(ans))


from math import sqrt
n = int(input())
arr = [[int(i) for i in input().split()] for j in range(n)]
for i in range(n):
	j = (i + 1) % n
	k = (i + 2) % n
	print(int(sqrt(arr[i][j] * arr[i][k] / arr[j][k])), end=' ')
print()


import math
n = int(input())
a = []
b = [0] * n
for i in range(n):
	x = []
	p = list(map(int, input().split()))
	for j in range(n):
		x.append(p[j])
	a.append(x)
s = a[0][1] * a[0][2] // a[1][2]
s = int(math.sqrt(s))
print(s, end=' ')
temp = s
for i in range(n - 1):
	print(a[i][i + 1] // temp, end=' ')
	temp = a[i][i + 1] // temp


n = int(input())
i = 1
first = input()
c_1 = [int(x) for x in first.split()]
first_1 = input()
c_2 = [int(x) for x in first_1.split()]
a1 = int((c_1[1] * c_1[2] / c_2[2]) ** 0.5)
a2 = int(c_2[0] / a1)
A = [a1, a2]
while i < n - 1:
	tmp = input()
	T = [int(x) for x in tmp.split()]
	a_i = int(T[0] / a1) * 1
	A.append(a_i)
	i += 1
i = 1
B = str(A[0])
while i < n:
	B += ' ' + str(A[i])
	i += 1
print(B)


import math
a = int(input())
b = []
mo = []
for x in range(a):
	b.append([int(y) for y in input().split()])
mo.append(math.sqrt(b[0][1] * b[0][2] * b[1][2]) / b[1][2])
for x in range(1, a - 1):
	mo.append(math.sqrt(b[x][x - 1] * b[x][x + 1] * b[x - 1][x + 1]) / b[x - 1][x + 1])
mo.append(math.sqrt(b[a - 1][a - 2] * b[a - 1][a - 3] * b[a - 2][a - 3]) / b[a - 2][a - 3])
for x in range(len(mo)):
	print(int(mo[x]), end=' ')


n = int(input())
grid = []
for i in range(n):
	l1 = list(map(int, input().split()))
	grid.append(l1)
first = grid[0][1] * grid[0][2]
first = first // grid[1][2]
first = int(first ** 0.5)
result = [first]
for i in range(1, n):
	result.append(grid[0][i] // first)
print(*result, sep=' ')