#pragma GCC optimize ("Ofast")
#include <bits/stdc++.h>
using namespace std;

template <class T> int sz(T&& a) { return int(size(forward<T>(a))); }

template <class T> using vc = vector<T>;
template <class T> using vvc = vc<vc<T>>;

using ll = int64_t;
using vi = vc<int>;

template <class F>
struct ycr {
	F f;
	
	template <class T>
	explicit ycr(T&& f_) : f(forward<T>(f_)) {}

	template <class... Args>
	decltype(auto) operator()(Args&&... args) {
		return f(ref(*this), forward<Args>(args)...);
	}
};
template <class F>
decltype(auto) yc(F&& f) {
	return ycr<decay_t<F>>(forward<F>(f));
}

int main() {
	ios_base::sync_with_stdio(false), cin.tie(nullptr);
	cout << fixed << setprecision(20);

	int N; cin >> N;
	
	using D = double;
	vector<D> xs(N), ys(N);
	for (int i = 0; i < N; i++) {
		cin >> xs[i] >> ys[i];
	}

	auto check = [&](string expr, vector<D> cur) -> void {
		for (int i = 0; i < N; i++) {
			if (abs(cur[i] - ys[i]) / max<D>(1, abs(ys[i])) > 1e-3) return;
		}
		cout << expr << '\n';
		exit(0);
	};

	const int L = 10;
	vector<vector<pair<string, vector<D>>>> vals(L);
	vals[0].push_back({"x", xs});
	vector<D> t(N);
	for (int c = 1; c < L; c++) {
		// sin/cos
		for (const auto& [expr, s] : vals[c-1]) {
			{
				for (int i = 0; i < N; i++) {
					t[i] = sin(s[i]);
				}
				auto new_expr = "sin(" + expr + ")";
				check(new_expr, t);
				vals[c].push_back({new_expr, t});
			}
			{
				for (int i = 0; i < N; i++) {
					t[i] = cos(s[i]);
				}
				auto new_expr = "cos(" + expr + ")";
				check(new_expr, t);
				vals[c].push_back({new_expr, t});
			}
		}
		for (int c0 = 0; c0 <= c-1-c0; c0++) {
			int c1 = c-1-c0;
			for (const auto& [expr0, s0] : vals[c0]) {
				for (const auto& [expr1, s1] : vals[c1]) {
					for (int i = 0; i < N; i++) {
						t[i] = s0[i] + s1[i];
					}
					auto new_expr = "(" + expr0 + ")+(" + expr1 + ")";
					check(new_expr, t);
					vals[c].push_back({new_expr, t});
				}
			}
			for (const auto& [expr0, s0] : vals[c0]) {
				for (const auto& [expr1, s1] : vals[c1]) {
					for (int i = 0; i < N; i++) {
						t[i] = s0[i] - s1[i];
					}
					auto new_expr = "(" + expr0 + ")-(" + expr1 + ")";
					check(new_expr, t);
					vals[c].push_back({new_expr, t});
				}
			}
			for (const auto& [expr0, s0] : vals[c0]) {
				for (const auto& [expr1, s1] : vals[c1]) {
					for (int i = 0; i < N; i++) {
						t[i] = s1[i] - s0[i];
					}
					auto new_expr = "(" + expr1 + ")-(" + expr0 + ")";
					check(new_expr, t);
					vals[c].push_back({new_expr, t});
				}
			}
			for (const auto& [expr0, s0] : vals[c0]) {
				for (const auto& [expr1, s1] : vals[c1]) {
					for (int i = 0; i < N; i++) {
						t[i] = s0[i] * s1[i];
					}
					auto new_expr = "(" + expr0 + ")*(" + expr1 + ")";
					check(new_expr, t);
					vals[c].push_back({new_expr, t});
				}
			}
			for (const auto& [expr0, s0] : vals[c0]) {
				for (const auto& [expr1, s1] : vals[c1]) {
					bool works = true;
					for (int i = 0; i < N; i++) {
						if (abs(s1[i]) < 1e-2) {
							works = false;
							break;
						}
						t[i] = s0[i] / s1[i];
					}
					if (!works) continue;
					auto new_expr = "(" + expr0 + ")/(" + expr1 + ")";
					check(new_expr, t);
					vals[c].push_back({new_expr, t});
				}
			}
			for (const auto& [expr0, s0] : vals[c0]) {
				for (const auto& [expr1, s1] : vals[c1]) {
					bool works = true;
					for (int i = 0; i < N; i++) {
						if (abs(s0[i]) < 1e-2) {
							works = false;
							break;
						}
						t[i] = s1[i] / s0[i];
					}
					if (!works) continue;
					auto new_expr = "(" + expr1 + ")/(" + expr0 + ")";
					check(new_expr, t);
					vals[c].push_back({new_expr, t});
				}
			}
		}
	}
}