#include <iostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <algorithm>
#include <numeric>
#include <iterator>
#include <functional>
#include <complex>
#include <queue>
#include <stack>
#include <cmath>
#include <cassert>
#include <tuple>
using namespace std;
typedef long long LL;
typedef complex<double> CMP;

class NeverAskHerAge { public:
	vector <int> possibleSolution(int n, vector <int> id1, vector <int> id2, vector <string> op, vector <string> rl, vector <int> val)
	{
		// !!!Being a geek, Jiro has to perfer 0-origin numbering!!!
		for(auto& g: id1) --g;
		for(auto& g: id2) --g;

		for(auto& s: rl) {if(s=="<=") s="L"; if(s==">=") s="G";}

		// check obviously false conditions.
		for(int i=0; i<id1.size(); ++i) if(rl[i]=="=") {
			if(op[i]=="/") {
				if(val[i]==0)
					return vector<int>();
				continue;
			}
			if(val[i]%1000 != 0)
				return vector<int>();
			int v = val[i] / 1000;
			if(op[i]=="+" && (v<2 || v>200)) return vector<int>();
			if(op[i]=="-" && (v<-99 || v>99)) return vector<int>();
			if(op[i]=="*") {
				if(v<1 || 10000<v) return vector<int>();
				for(int p=2; p*p<=v; ++p)
					while(v%p==0)v/=p;
				if(v>100) return vector<int>();
			}
		}

		// Relevant constraints
		vector<set<int>> rel(n);
		for(int i=0; i<id1.size(); ++i) rel[id1[i]].insert(i);
		for(int i=0; i<id2.size(); ++i) rel[id2[i]].insert(i);

		// Try highly constrained girl first.
		vector<int> girls; for(int g=0; g<n; ++g) girls.push_back(g);
		sort(girls.begin(), girls.end(), [&](int g1, int g2){return rel[g1].size()>rel[g2].size();});

		const int UNDETERMINED = 0;
		vector<int> x(n, UNDETERMINED);
		function<bool(int)> rec;
		rec = [&](int gi){
			if(gi == n)
				return true;
			int g = girls[gi];
			for(int age=1; age<=100; ++age)
			{
				x[g] = age;
				bool bad = false;
				for(int i: rel[g]) if(x[id1[i]]!=UNDETERMINED && x[id2[i]]!=UNDETERMINED) {
					if(!ok(x[id1[i]], op[i][0], x[id2[i]], rl[i][0], val[i]))
						{bad=true; break;}
				} else {
					if(!ok_part(x[id1[i]], op[i][0], x[id2[i]], rl[i][0], val[i]))
						{bad=true; break;}
				}
				if(!bad && rec(gi+1))
					return true;
				x[g] = UNDETERMINED;
			}
			return false;
		};
		if(!rec(0)) return vector<int>();
		return x;
	}

	static bool ok(int x1, char op, int x2, char rl, int val)
	{
		switch(op) {
		case '+': return ok((x1+x2)*1000, rl, val);
		case '-': return ok((x1-x2)*1000, rl, val);
		case '*': return ok((x1*x2)*1000, rl, val);
		case '/': return ok((x1)*1000, rl, val*x2);
		}
		return false;
	}
	static bool ok(int x, char rel, int y)
	{
		if(rel=='<') return x < y;
		if(rel=='L') return x <= y;
		if(rel=='>') return x > y;
		if(rel=='G') return x >= y;
		if(rel=='=') return x == y;
		return false;
	}
	static bool ok_part(int x1, char op, int x2, char rl, int val)
	{
		switch(op) {
		case '+': return ok_part_plus(max(x1,x2), rl, val);
		case '-': return x1 ? ok_part_minusl(x1, rl, val)
					        : ok_part_minusr(x2, rl, val);
		case '*': return ok_part_mult(max(x1,x2), rl, val);
		case '/': return x1 ? ok_part_divl(x1, rl, val)
					        : ok_part_divr(x2, rl, val);
		}
		return true;
	}
	// (x + ?)*1000 rel y
	static bool ok_part_plus(int x, char rel, int y)
	{
		if(rel=='<') return (x+1)*1000 < y;
		if(rel=='L') return (x+1)*1000 <= y;
		if(rel=='>') return (x+100)*1000 > y;
		if(rel=='G') return (x+100)*1000 >= y;
		if(rel=='=') return (x+1)*1000<=y && y<=(x+100)*1000;
		return false;
	}
	// (x - ?)*1000 rel y
	static bool ok_part_minusl(int x, char rel, int y)
	{
		if(rel=='<') return (x-100)*1000 < y;
		if(rel=='L') return (x-100)*1000 <= y;
		if(rel=='>') return (x-1)*1000 > y;
		if(rel=='G') return (x-1)*1000 >= y;
		if(rel=='=') return (x-100)*1000<=y && y<=(x-1)*1000;
		return false;
	}
	// (? - x)*1000 rel y
	static bool ok_part_minusr(int x, char rel, int y)
	{
		if(rel=='<') return (1-x)*1000 < y;
		if(rel=='L') return (1-x)*1000 <= y;
		if(rel=='>') return (100-x)*1000 > y;
		if(rel=='G') return (100-x)*1000 >= y;
		if(rel=='=') return (1-x)*1000<=y && y<=(100-x)*1000;
		return false;
	}
	// (x * ?)*1000 rel y
	static bool ok_part_mult(int x, char rel, int y)
	{
		if(rel=='<') return (x*1)*1000 < y;
		if(rel=='L') return (x*1)*1000 <= y;
		if(rel=='>') return (x*100)*1000 > y;
		if(rel=='G') return (x*100)*1000 >= y;
		if(rel=='=') return (x*1)*1000<=y && y<=(x*100)*1000 && y%(x*1000)==0;
		return false;
	}
	// (x / ?)*1000 rel y
	static bool ok_part_divl(int x, char rel, int y)
	{
		if(rel=='<') return x*1000 < y*100;
		if(rel=='L') return x*1000 <= y*100;
		if(rel=='>') return x*1000 > y*1;
		if(rel=='G') return x*1000 >= y*1;
		if(rel=='=') return x*1000 <= y*100 && x*1000 >= y*1 && (x*1000%y==0);
		return false;
	}
	static bool ok_part_divr(int x, char rel, int y)
	{
		return true;
	}
};

// BEGIN CUT HERE
#include <ctime>
double start_time; string timer()
 { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
 { os << "{ ";
   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
void verify_case(const vector <int>& Expected, const vector <int>& Received) {
 bool ok = (Expected == Received);
 if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
 cerr << "\to: " << Expected << endl << "\tx: " << Received << endl; } }
#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
#define END	 verify_case(_, NeverAskHerAge().possibleSolution(n, id1, id2, op, rl, val));}
int main(){

CASE(0)
	int n = 2; 
	int id1_[] = {1,1};
	  vector <int> id1(id1_, id1_+sizeof(id1_)/sizeof(*id1_)); 
	int id2_[] = {2,2};
	  vector <int> id2(id2_, id2_+sizeof(id2_)/sizeof(*id2_)); 
	string op_[] = {"+","*"};
	  vector <string> op(op_, op_+sizeof(op_)/sizeof(*op_)); 
	string rl_[] = {"=","="};
	  vector <string> rl(rl_, rl_+sizeof(rl_)/sizeof(*rl_)); 
	int val_[] = {10000,21000};
	  vector <int> val(val_, val_+sizeof(val_)/sizeof(*val_)); 
	int __[] = {3, 7 };
	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
END
CASE(1)
	int n = 7; 
	int id1_[] = {1,2,3,4,5,6};
	  vector <int> id1(id1_, id1_+sizeof(id1_)/sizeof(*id1_)); 
	int id2_[] = {2,3,4,5,6,7};
	  vector <int> id2(id2_, id2_+sizeof(id2_)/sizeof(*id2_)); 
	string op_[] = {"/","/","/","/","/","/"};
	  vector <string> op(op_, op_+sizeof(op_)/sizeof(*op_)); 
	string rl_[] = {"=","=","=","=","=","="};
	  vector <string> rl(rl_, rl_+sizeof(rl_)/sizeof(*rl_)); 
	int val_[] = {2000,2000,2000,2000,2000,2000};
	  vector <int> val(val_, val_+sizeof(val_)/sizeof(*val_)); 
	int __[] = {64, 32, 16, 8, 4, 2, 1 };
	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
END
CASE(2)
	int n = 2; 
	int id1_[] = {1,1};
	  vector <int> id1(id1_, id1_+sizeof(id1_)/sizeof(*id1_)); 
	int id2_[] = {2,2};
	  vector <int> id2(id2_, id2_+sizeof(id2_)/sizeof(*id2_)); 
	string op_[] = {"/","/"};
	  vector <string> op(op_, op_+sizeof(op_)/sizeof(*op_)); 
	string rl_[] = {">","<"};
	  vector <string> rl(rl_, rl_+sizeof(rl_)/sizeof(*rl_)); 
	int val_[] = {2621,2622};
	  vector <int> val(val_, val_+sizeof(val_)/sizeof(*val_)); 
	int __[] = {97, 37 };
	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
END
CASE(3)
	int n = 2; 
	int id1_[] = {1,1};
	  vector <int> id1(id1_, id1_+sizeof(id1_)/sizeof(*id1_)); 
	int id2_[] = {2,2};
	  vector <int> id2(id2_, id2_+sizeof(id2_)/sizeof(*id2_)); 
	string op_[] = {"*","+"};
	  vector <string> op(op_, op_+sizeof(op_)/sizeof(*op_)); 
	string rl_[] = {">","<="};
	  vector <string> rl(rl_, rl_+sizeof(rl_)/sizeof(*rl_)); 
	int val_[] = {6000,5000};
	  vector <int> val(val_, val_+sizeof(val_)/sizeof(*val_)); 
	vector <int> _; 
END
CASE(4)
	int n = 8; 
	int id1_[] = {1,3,5,7};
	  vector <int> id1(id1_, id1_+sizeof(id1_)/sizeof(*id1_)); 
	int id2_[] = {2,4,6,8};
	  vector <int> id2(id2_, id2_+sizeof(id2_)/sizeof(*id2_)); 
	string op_[] = {"+","-","*","/"};
	  vector <string> op(op_, op_+sizeof(op_)/sizeof(*op_)); 
	string rl_[] = {">=","<=","=","<="};
	  vector <string> rl(rl_, rl_+sizeof(rl_)/sizeof(*rl_)); 
	int val_[] = {200000,-99000,3589000,10};
	  vector <int> val(val_, val_+sizeof(val_)/sizeof(*val_)); 
	int __[] = {100, 100, 1, 100, 97, 37, 1, 100 };
	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
END
CASE(5)
	int n = 8; 
	int id1_[] = {7,1,3,4,4,3,7,2,3,6,4,4,6,5,2,8,2,2,7,6,2,2,8,6,5,6,5,4,4,8,6,1,3,5,5,4,3,7,4,8};
	  vector <int> id1(id1_, id1_+sizeof(id1_)/sizeof(*id1_)); 
	int id2_[] = {2,7,6,6,1,2,4,7,4,4,8,3,8,2,4,1,7,7,6,2,5,7,6,5,8,2,8,1,8,1,3,2,7,1,2,2,1,8,3,3};
	  vector <int> id2(id2_, id2_+sizeof(id2_)/sizeof(*id2_)); 
	string op_[] = {"/","*","/","-","*","+","*","+","/","+","-","+","*","+","/","*","-","/","-","*","/","/","/","*","/","+","+","*","*","-","-","*","+","+","+","-","+","/","+","*"};
	  vector <string> op(op_, op_+sizeof(op_)/sizeof(*op_)); 
	string rl_[] = {"<","<","<=",">","<","<=","<",">","<","<=","<=",">",">",">=","<",">","<","<",">",">=","<=","<","<=",">=","<=",">=",">=",">=","<=",">=","<=",">","<=","<",">","<=",">=","<","<=","<="};
	  vector <string> rl(rl_, rl_+sizeof(rl_)/sizeof(*rl_)); 
	int val_[] = {47636,5754558,3307,-41496,7043286,144246,5048203,72315,85384,182630,50604,9802,3843942,152392,60035,149684,94234,31209,-73898,195742,8383,71993,98477,4859384,74619,146266,60163,377564,5357728,-80040,72545,1088942,87517,192354,18629,45785,44151,95334,140360,1063484};
	  vector <int> val(val_, val_+sizeof(val_)/sizeof(*val_)); 
	int __[] = {56, 77, 19, 59, 77, 87, 43, 51 };
	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
END
CASE(6)
	int n = 8; 
	int id1_[] = {7,1,3,4,4,3,7,2,3,6,4,4,6,5,2,8,2,2,7,6,2,2,8,6,5,6,5,4,4,8,6,1,3,5,5,4,3,7,4,8};
	  vector <int> id1(id1_, id1_+sizeof(id1_)/sizeof(*id1_)); 
	int id2_[] = {2,7,6,6,1,2,4,7,4,4,8,3,8,2,4,1,7,7,6,2,5,7,6,5,8,2,8,1,8,1,3,2,7,1,2,2,1,8,3,3};
	  vector <int> id2(id2_, id2_+sizeof(id2_)/sizeof(*id2_)); 
	string op_[] = {"/","*","/","-","*","+","*","+","/","+","-","+","*","+","/","*","-","/","-","*","/","/","/","*","/","+","+","*","*","-","-","*","+","+","+","-","+","/","+","*"};
	  vector <string> op(op_, op_+sizeof(op_)/sizeof(*op_)); 
	string rl_[] = {"=","<","<=",">","<","<=","<",">","<","<=","<=",">",">",">=","<",">","<","<",">",">=","<=","<","<=",">=","<=",">=",">=",">=","<=",">=","<=",">","<=","<",">","<=",">=","<","<=","<="};
	  vector <string> rl(rl_, rl_+sizeof(rl_)/sizeof(*rl_)); 
	int val_[] = {2000,5754558,3307,-41496,7043286,144246,5048203,72315,85384,182630,50604,9802,3843942,152392,60035,149684,94234,31209,-73898,195742,8383,71993,98477,4859384,74619,146266,60163,377564,5357728,-80040,72545,1088942,87517,192354,18629,45785,44151,95334,140360,1063484};
	  vector <int> val(val_, val_+sizeof(val_)/sizeof(*val_)); 
	vector <int> _; 
END
/*
CASE(7)
	int n = ; 
	int id1_[] = ;
	  vector <int> id1(id1_, id1_+sizeof(id1_)/sizeof(*id1_)); 
	int id2_[] = ;
	  vector <int> id2(id2_, id2_+sizeof(id2_)/sizeof(*id2_)); 
	string op_[] = ;
	  vector <string> op(op_, op_+sizeof(op_)/sizeof(*op_)); 
	string rl_[] = ;
	  vector <string> rl(rl_, rl_+sizeof(rl_)/sizeof(*rl_)); 
	int val_[] = ;
	  vector <int> val(val_, val_+sizeof(val_)/sizeof(*val_)); 
	int __[] = ;
	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
END
CASE(8)
	int n = ; 
	int id1_[] = ;
	  vector <int> id1(id1_, id1_+sizeof(id1_)/sizeof(*id1_)); 
	int id2_[] = ;
	  vector <int> id2(id2_, id2_+sizeof(id2_)/sizeof(*id2_)); 
	string op_[] = ;
	  vector <string> op(op_, op_+sizeof(op_)/sizeof(*op_)); 
	string rl_[] = ;
	  vector <string> rl(rl_, rl_+sizeof(rl_)/sizeof(*rl_)); 
	int val_[] = ;
	  vector <int> val(val_, val_+sizeof(val_)/sizeof(*val_)); 
	int __[] = ;
	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
END
*/
}
// END CUT HERE
