#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;

#define REP(i,n) for(long long i = 0; i < (n); i++)
#define FOR(i, m, n) for(long long i = (m);i < (n); ++i)
#define ALL(obj) (obj).begin(),(obj).end()
#define SPEED cin.tie(0);ios::sync_with_stdio(false);

template<class T> using V = vector<T>;
template<class T, class U> using P = pair<T, U>;

const ll MOD = (ll)1e9 + 7;
const ll MOD2 = 998244353;
const ll HIGHINF = (ll)1e18;
const ll LOWINF = (ll)1e15;
const long double PI = 3.1415926535897932384626433;

template <class T> void corner(bool flg, T hoge) {if (flg) {cout << hoge << endl; exit(0);}}
template <class T, class U>ostream &operator<<(ostream &o, const map<T, U>&obj) {o << "{"; for (auto &x : obj) o << " {" << x.first << " : " << x.second << "}" << ","; o << " }"; return o;}
template <class T>ostream &operator<<(ostream &o, const set<T>&obj) {o << "{"; for (auto itr = obj.begin(); itr != obj.end(); ++itr) o << (itr != obj.begin() ? ", " : "") << *itr; o << "}"; return o;}
template <class T>ostream &operator<<(ostream &o, const multiset<T>&obj) {o << "{"; for (auto itr = obj.begin(); itr != obj.end(); ++itr) o << (itr != obj.begin() ? ", " : "") << *itr; o << "}"; return o;}
template <class T>ostream &operator<<(ostream &o, const vector<T>&obj) {o << "{"; for (int i = 0; i < (int)obj.size(); ++i)o << (i > 0 ? ", " : "") << obj[i]; o << "}"; return o;}
template <class T, class U>ostream &operator<<(ostream &o, const pair<T, U>&obj) {o << "{" << obj.first << ", " << obj.second << "}"; return o;}
template <template <class tmp>  class T, class U> ostream &operator<<(ostream &o, const T<U> &obj) {o << "{"; for (auto itr = obj.begin(); itr != obj.end(); ++itr)o << (itr != obj.begin() ? ", " : "") << *itr; o << "}"; return o;}
void print(void) {cout << endl;}
template <class Head> void print(Head&& head) {cout << head;print();}
template <class Head, class... Tail> void print(Head&& head, Tail&&... tail) {cout << head << " ";print(forward<Tail>(tail)...);}
template <class T> void chmax(T& a, const T b){a=max<T>(a,b);}
template <class T> void chmin(T& a, const T b){a=min<T>(a,b);}
void YN(bool flg) {cout << ((flg) ? "YES" : "NO") << endl;}
void Yn(bool flg) {cout << ((flg) ? "Yes" : "No") << endl;}
void yn(bool flg) {cout << ((flg) ? "yes" : "no") << endl;}


class Lowest_Common_Ancestor {
public:
	int N, MAX_bit;
	vector<vector<int>> edge;
	vector<int> depth;
	vector<vector<int>> parent;
	vector<vector<int>> child;
	vector<vector<int>> descendant;

	Lowest_Common_Ancestor(int N, int MAX_bit = 20) :N(N), MAX_bit(MAX_bit), edge(N), depth(N, -1), parent(N, vector<int>(MAX_bit)), child(N), descendant(N){
		//do nothing
	}

	//O(1)
	void make_edge(int from, int to) {
		edge[from].push_back(to);
	}

	//O(N)
	void make_depth(int root) {
		queue<int> q;
		depth[root] = 0;
		q.push(root);
		while (q.size()) {
			int from = q.front();
			q.pop();
			for (auto to : edge[from]) {
				if (depth[to] != -1) continue;
				depth[to] = depth[from] + 1;
				q.push(to);
			}
		}
	}

	//O(MAX_bit*N)
	void make_parent() {
		for (int i = 0; i < N; ++i) parent[i][0] = i;
		for (int i = 0; i < N; ++i) for (auto j : edge[i]) if (depth[i] > depth[j]) parent[i][0] = j;
		for (int bit = 1; bit < MAX_bit; ++bit) for (int i = 0; i < N; ++i) parent[i][bit] = parent[parent[i][bit - 1]][bit - 1];
	}

	//O(N)
	void make_child() {
		for (int i = 0; i < N; ++i) for (auto j : edge[i]) if (depth[i] < depth[j]) child[i].push_back(j);
	}

	//O(N^2)
	void make_descendant() {
		vector<pair<int,int>> ord(N);
		for (int i = 0; i < N; ++i) ord[i] = {depth[i],i};
		sort(ord.begin(),ord.end(),greater<>());
		for (int i = 0; i < N; ++i) descendant[i].push_back(i);
		for (int i = 0; i < N; ++i) for (auto j : edge[ord[i].second]) if (depth[ord[i].second] < depth[j]) for(auto k: descendant[j]) descendant[ord[i].second].push_back(k);
	}

	//O(MAX_bit*logN)
	int lca(int l, int r) {
		if (depth[l] < depth[r]) swap(l, r);
		int diff = depth[l] - depth[r];
		for (int bit = 0; bit < MAX_bit; ++bit) if (diff & (1 << bit)) l = parent[l][bit];
		int ok = (1 << MAX_bit), ng = -1, md;
		while (ok - ng>1) {
			md = (ok + ng) / 2;
			int x = l, y = r;
			for (int bit = 0; bit < MAX_bit; ++bit) if (md & (1 << bit)) x = parent[x][bit];
			for (int bit = 0; bit < MAX_bit; ++bit) if (md & (1 << bit)) y = parent[y][bit];
			(x == y ? ok : ng) = md;
		}
		for (int bit = 0; bit < MAX_bit; ++bit) if (ok & (1 << bit)) l = parent[l][bit];
		return l;
	}

	void print() {
		cout << " depth { " << depth[0];
		for (int i = 1; i < N; ++i) cout << ", " << depth[i];
		cout << " }" << endl;

		cout << "parent { " << parent[0][0];
		for (int i = 1; i < N; ++i) cout << ", " << parent[i][0];
		cout << " }" << endl;

		cout << " child { " << child[0];
		for (int i = 1; i < N; ++i) cout << ", " << child[i];
		cout << " }" << endl;

		cout << "descen { " << descendant[0];
		for (int i = 1; i < N; ++i) cout << ", " << descendant[i];
		cout << " }" << endl;
	}

};

vector<long long> Prime_Factorization(long long N) {
    vector<long long> ret;
    if (N == 1) ret.push_back(1);
    for (long long i = 2,M = N; i*i <= M; ++i) {
        if (N%i == 0) ret.push_back(i);
        while (N%i == 0) N /= i;
    }
    if (N != 1) ret.push_back(N);
    return ret;
}

//Greatest Common Divisor
long long GCD(long long a, long long b) {
    return ((b == 0) ? a : GCD(b, a % b));
}

int main() {
    while(1){
        int N; cin >> N;
        if(N==0) return 0;
        V<int> p(N),q(N),l(N),r(N), vst(N,0), dp(N,1);
        for(int i = 0; i < N; ++i) cin >> p[i] >> q[i] >> l[i] >> r[i];
        Lowest_Common_Ancestor tree(N);
        for(int i = 0; i < N; ++i){
            l[i]--,r[i]--;
            if(l[i]!=-1) tree.make_edge(i,l[i]);
            if(l[i]!=-1) vst[l[i]]++;
            if(r[i]!=-1) tree.make_edge(i,r[i]);
            if(r[i]!=-1) vst[r[i]]++;
        }
        int root = min_element(ALL(vst)) - vst.begin();
        tree.make_depth(root);
        V<P<int,int>> ord(N);
        for(int i = 0; i < N; ++i) ord[i] = {-tree.depth[i],i};
        sort(ALL(ord));
        for(int i = 0; i < N; ++i){
            int idx = ord[i].second;
            ll g = GCD(p[idx],q[idx]);
            p[idx] /= g;
            q[idx] /= g;
            ll s = p[idx], t = q[idx];
            if(l[idx]!=-1) p[idx] *= dp[l[idx]];
            if(r[idx]!=-1) q[idx] *= dp[r[idx]];
            auto pl = Prime_Factorization(p[idx]);
            auto pr = Prime_Factorization(q[idx]);
            map<ll,ll> mpl,mpr,mp;
            for(auto e: pl){
                while(e!=1&&p[idx]%e==0){
                    mpl[e]++;
                    p[idx]/=e;
                }
                mp[e];
            }
            for(auto e: pr){
                while(e!=1&&q[idx]%e==0){
                    mpr[e]++;
                    q[idx]/=e;
                }
                mp[e];
            }

            ll cnt = 1;
            for(auto e:mp){
                ll k = max(mpl[e.first],mpr[e.first]);
                for(int j = 0; j < k; ++j) cnt *= e.first;
            }
            dp[idx] = cnt/s + cnt/t;
        }
        cout << dp[root] << endl;
    }
    return 0;
}



Measured memory_bytes: 3068