Go: package main

import (
	"bufio"
	"os"
	"strconv"
	"strings"
	"fmt"
)

var scanner = bufio.NewScanner(os.Stdin)

func main() {
	for scanner.Scan() {
		n, _ := strconv.Atoi(scanner.Text())
		if n == 0 {
			break
		}
		d, v := make([]int, 0), make([]int, 0)
		for i := 0; i < n; i++ {
			scanner.Scan()
			buf := strings.Split(scanner.Text(), " ")
			a, _ := strconv.Atoi(buf[0])
			b, _ := strconv.Atoi(buf[1])
			g := _gcd(a, b)
			a /= g
			b /= g
			d = append(d, a)
			v = append(v, b)
		}
		g := lcm(n, d)
		for i := 0; i < n; i++ {
			d[i] = (g/d[i])*v[i]
		}
		g = gcd(n, d)
		for i := 0; i < n; i++ {
			fmt.Println(d[i]/g)
		}
	}
}

func _gcd(a, b int) int {
	for b != 0 {
		r := a % b
		a, b = b, r
	}
	return a
}

func gcd(n int, a []int) int {
	if n == 1 {
		return a[0]
	}
	g := _gcd(a[0], a[1])
	for i := 2; i < n; i++ {
		if g == 1 {
			break
		}
		g = _gcd(g, a[i])
	}
	return g
}

func lcm(n int, a []int) int {
	if n == 1 {
		return a[0]
	}
	g := _gcd(a[0], a[1])
	c := a[0] / g * a[1]
	for i := 2; i < n; i++ {
		g = _gcd(c, a[i])
		c = c / g * a[i]
	}
	return c
}

C++: #include <iostream>
#include <vector>
using namespace std;
typedef unsigned long long ull;

ull gcd(ull x, ull y)
{
  if (x < y) {
    swap(x, y);
  }
  ull r;
  while ((r = x % y) != 0) {
    x = y;
    y = r;
  }
  return y;
}

int main()
{
  int N;
  while (cin >> N && N != 0) {
    vector<pair<ull,ull> > v(N);
    for (int i = 0; i < N; i++) {
      ull d, w;
      cin >> d >> w;
      v[i] = make_pair(d, w);
    }

    ull g = v[0].first;
    ull l = v[0].first;
    for (int i = 1; i < N; i++) {
      g = gcd(g, v[i].first);
      l *= v[i].first;
    }
    l /= g;

    vector<ull> gs(N);
    gs[0] = v[0].second*(l/v[0].first);
    ull h = gs[0];
    for (int i = 1; i < N; i++) {
      gs[i] = v[i].second*(l/v[i].first);
      h = gcd(h, gs[i]);
    }
    for (int i = 0; i < N; i++) {
      cout << gs[i]/h << endl;
    }
  }
  return 0;
}

C++: #include <bits/stdc++.h>
#define PB push_back
#define MP make_pair
#define REP(i,n) for (int i=0;i<(n);i++)
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define ALL(a) (a).begin(),(a).end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
const int INF=1e9;
ll gcd(ll a,ll b){
      if(b==0)return a;
      return gcd(b,a%b);
}
ll lcm(ll a,ll b){
      return a/gcd(a,b)*b;
}
int main(){
      ll n,d[10],v[10];
      while(cin>>n&&n){
            ll c;
            REP(i,n){
                  cin>>d[i]>>v[i];
                  if(i==0)c=v[i];
                  else c=lcm(v[i],c);
            }
            REP(i,n)d[i]=c/v[i]*d[i];
            ll ans=0;
            REP(i,n){
                  if(i==0)ans=d[i];
                  else ans=lcm(ans,d[i]);
            }
            REP(i,n){
                  cout<<ans/d[i]<<endl;
            }
      }
}

C++: #include <iostream>

typedef long long ll;

ll gcd(ll a, ll b){
	if (b == 0)return a;
	else return gcd(b, a % b);
}

ll lcm(ll a, ll b){
	ll c = gcd(a, b);
	return c * (a / c) * (b / c);
}

int main(){
	int n;
	while (std::cin >> n, n){
		ll d[11], v[11], p[11], mul = 1;
		for (int i = 0; i < n; ++i)std::cin >> d[i] >> v[i], mul = lcm(mul, v[i]);
		for (int i = 0; i < n; ++i)p[i] = d[i] * (mul / v[i]);
		ll ans = lcm(p[0], p[1]);
		for (int i = 2; i < n; ++i)ans = lcm(ans, p[i]);
		for (int i = 0; i < n; ++i)std::cout << ans / p[i] << std::endl;
	}
	return 0;
}

C++: #include <algorithm>
#include <iostream>
using namespace std;
#define LL long long

LL gcd(LL a,LL b){
	if(a<b)swap(a,b);
	while(b!=0){
		LL t=b;
		b=a%b;
		a=t;
	}
	return a;
}


int main(){
	
	int n;
	while(cin>>n,n){
		LL d[10],v[10];
		for(int i=0;i<n;i++){
			cin>>d[i]>>v[i];
			LL t=gcd(d[i],v[i]);
			d[i]/=t;
			v[i]/=t;
		}
		LL dk=d[0],vk=v[0];
		for(int i=1;i<n;i++){
			dk=dk*d[i]/gcd(d[i],dk);
			vk=gcd(vk,v[i]);
		}
		for(int i=0;i<n;i++){
			cout<<(v[i]/vk)*(dk/d[i])<<endl;
		}
	}
	
	return 0;
}

C++: #include<cstdio>
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<cmath>

using namespace std;

#define reps(i,f,n) for(int i=f;i<int(n);i++)
#define rep(i,n) reps(i,0,n)

#ifdef __BORLANDC__
	typedef __int64 ll;
#else 
	typedef long long ll;
#endif


int n;
vector<int> d;
vector<int> s;
bool input(){
	cin>>n;
	if(n==0)return false;
	d=vector<int>(n);
	s=vector<int>(n);
	rep(i,n){
		cin>>d[i]>>s[i];
	}
	return true;
}

typedef pair<ll,ll> pll;

pll tubun(pll a){
	ll mini = min(a.first, a.second);
	for(int i=2;i*i<=mini;i++){
		if(a.first%i==0 && a.second%i==0)
		{
			a.first/=i;
			a.second/=i;
			i--;
			
			mini = min(a.first, a.second);
		}
	}
	return a;
}

ll gcd(ll a, ll b){
	if(a<b)swap(a,b);
	
	while(1){
		ll c = a%b;
		if(c==0)return b;
		a = b;
		b = c;
	}
	return -1;
}
ll lcm(ll a, ll b, ll c, ll d){
	pll tes1 = tubun(pll(a,b));
	pll tes2 = tubun(pll(c,d));
	
	a = tes1.first;  b = tes1.second;
	c = tes2.first;  d = tes2.second;
	
	
	ll bunbo = b*d;
	ll A = a*d;
	ll B = b*c;
	ll C = gcd(A,B);
	ll bunshi = A/C * B/C * C;
	
	return bunshi/bunbo;
}

ll ngcd(ll a, ll b){
	if(a<b)swap(a,b);
	while(1){
		ll c = a%b;
		if(c==0)return b;
		a = b;
		b = c;
	}
	return -1;
}


const int N = 10;

vector<int> solve(){
	vector<int> ret;
	
	rep(i,n){
		pll hoge = tubun(pll(d[i],s[i]));
		d[i] = hoge.first;
		s[i] = hoge.second;
	}
	
	ll mygcd = gcd(s[0],s[1]);
	reps(i,2,n)mygcd = ngcd(mygcd, s[2]);
	rep(i,n)s[i]/=mygcd;
	
	ll mylcm = lcm(d[0],s[0],d[1],s[1]);
	reps(i,2,n){
		mylcm = lcm(mylcm, 1, d[i], s[i]);
	}
	
	rep(i,n){
		ret.push_back((int)(mylcm/d[i]*s[i]));
	}
	
	return ret;
}

void c_solve(){
	vector<int> ans = solve();
	rep(i,ans.size())cout<<ans[i]<<endl;
}

int main(){
	while(input())c_solve();	
}

C++: #include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

typedef long long ll;

ll gcd(ll a,ll b){
	if(b==0)
		return a;
	else
		return gcd(b,a%b);
}

ll lcm(ll a,ll b){
	return a*b/gcd(a,b);
}


void divs(ll &d,ll &v){
	for(ll i = 2; i <= min(d,v); i++){
		if(d%i==0&&v%i==0){
			d/=i;
			v/=i;
			i=1;
		}
	}
}

int main(){

	ll n;
	while(cin>>n&&n!=0){
		ll d,v;
		vector<ll> ds;
		vector<ll> vs;
		bool oo=false;
		for(ll i = 0; i < n; i++){
			cin>>d>>v;

			divs(d,v);


			ds.push_back(d);
			vs.push_back(v);
		}


		ll z=1;
		ll nums[11];
		ll allv=1;

		bool same=true;
		for(ll i = 1; i < n; i++){
			ll n1=ds[i-1]*vs[i];
			ll n2=ds[i]*vs[i-1];
			ll ret=lcm(n1,n2);
			ll r1=ret/n1;
			ll r2=ret/n2;
			if(ds[i-1]==ds[i]&&vs[i-1]==vs[i]){
				z=lcm(z,1);
				same=true;
			}
			else{
			//	if(vs[i-1]!=0)
					z=lcm(z,r1*ds[i-1]/vs[i-1]);
//				else
//					z=1;
				same=false;
			}
		}
		vector<ll> vll;
		ll m;
		if(!same){
			for(ll i = 0; i < n; i++){
				//if(ds[i]!=0){
					vll.push_back(z*vs[i]/ds[i]);
					if(i==0){
						m=z*vs[i]/ds[i];
					}
					else{
						m=gcd(m,z*vs[i]/ds[i]);
					}
			///	}
			//	else{
					vll.push_back(1);
					m=1;
			//	}
			}
			for(int i = 0; i < n; i++){
				if(m!=0)
					cout<<vll[i]/m<<endl;
				else
					cout<<1<<endl;
			}
		}
		else{
			for(int i = 0; i < n; i++){
				cout<<1<<endl;
			}
		}
	}

	return 0;
}