#include<bits/stdc++.h>
using namespace std;

#define all(x) x.begin(), x.end()

using ld = long double;

vector<vector<int>> g;
vector<int> type;

vector<pair<ld, ld>> eq;

mt19937 rnd(4235);

pair<ld, bool> evaluate(ld x, int u) {
    if (g[u].size() == 0) return {x, 0};
    if (g[u].size() == 1) {
        pair<ld, bool> val = evaluate(x, g[u][0]);
        if (val.second) return {0, 1};
        if (type[u] == 0) val.first = sin(val.first);
        if (type[u] == 1) val.first = cos(val.first);
        return val;
    }
    if (g[u].size() == 2) {
        pair<ld, bool> v1 = evaluate(x, g[u][0]);
        pair<ld, bool> v2 = evaluate(x, g[u][1]);
        if (v1.second || v2.second) return {0, 1};
        switch (type[u]) {
            case 0: v1.first += v2.first; return v1;
            case 1: v1.first -= v2.first; return v1;
            case 2: v1.first *= v2.first; return v1;
            case 3:
                if (abs(v2.first) <= 0.01) return {0, 1};
                v1.first /= v2.first;
                return v1;
        }
    }
}

string gen_ans(int u) {
    if (g[u].size() == 0) return "x";
    if (g[u].size() == 1) {
        if (type[u] == 0) return "sin(" + gen_ans(g[u][0]) + ")";
        if (type[u] == 1) return "cos(" + gen_ans(g[u][0]) + ")";
    }
    if (g[u].size() == 2) {
        switch (type[u]) {
            case 0: return "(" + gen_ans(g[u][0]) + ")+(" + gen_ans(g[u][1]) + ")";
            case 1: return "(" + gen_ans(g[u][0]) + ")-(" + gen_ans(g[u][1]) + ")";
            case 2: return "(" + gen_ans(g[u][0]) + ")*(" + gen_ans(g[u][1]) + ")";
            case 3: return "(" + gen_ans(g[u][0]) + ")/(" + gen_ans(g[u][1]) + ")";
        }
    }
}

void gen2(int i) {
    if (i == g.size()) {
        bool ok = 1;
        for (auto [x, y] : eq) {
            auto [val, fl] = evaluate(x, 0);
            if (fl) {
                ok = 0;
                break;
            }
            if (abs(val - y) / max((ld)1, abs(y)) <= 1e-3) {}
            else {
                ok = 0;
                break;
            }
        }
        if (ok) {
            cout << gen_ans(0);
            exit(0);
        }
        return;
    }
    if (g[i].size() == 0) {
        type[i] = 0;
        gen2(i + 1);
    } else if (g[i].size() == 1) {
        for (type[i] = 0; type[i] < 2; ++type[i]) gen2(i + 1);
    } else {
        for (type[i] = 0; type[i] < 4; ++type[i]) gen2(i + 1);
    }
}

bool ok;
int ptr;
int gen(string s) {
    if (s.empty()) return -1;
    int u = ptr++;
    int bal = 0;
    for (int i = 0; i < s.size(); ++i) {
        bal += (s[i] == '(') - (s[i] == ')');
        if (bal == 0) {
            if (i + 1 == s.size() && i != 1) {
                ok = 0;
                break;
            }
            int v;
            v = gen(string(s.begin() + 1, s.begin() + i));
            if (v != -1) g[u].push_back(v);
            v = gen(string(s.begin() + i + 1, s.end()));
            if (v != -1) g[u].push_back(v);
            break;
        }
    }
    return u;
}

string cur;
int bal;

void gen(int i) {
    if (i == cur.size()) {
        g.assign(cur.size() / 2, {});
        type.resize(cur.size() / 2);
        ptr = 0;
        ok = 1;
        gen(cur);
        if (!ok) return;
        gen2(0);
        return;
    }
    if (rnd() & 1) {
        if (bal > 0) {
            bal--;
            cur[i] = ')';
            gen(i + 1);
            bal++;
        }
        if (bal + 1 <= (cur.size() - i - 1)) {
            bal++;
            cur[i] = '(';
            gen(i + 1);
            bal--;
        }
    } else {
        if (bal + 1 <= (cur.size() - i - 1)) {
            bal++;
            cur[i] = '(';
            gen(i + 1);
            bal--;
        }
        if (bal > 0) {
            bal--;
            cur[i] = ')';
            gen(i + 1);
            bal++;
        }
    }
}

signed main() {
    cin.tie(0)->sync_with_stdio(0);

    int n;
    cin >> n;
    eq.resize(n);
    for (int i = 0; i < n; ++i) cin >> eq[i].first >> eq[i].second;
    vector<int> lenn;
    for (int len = 2; len <= 20; len += 2) {
        lenn.push_back(len);
        cur = string(len, '#');
        gen(0);
    }
    shuffle(lenn.begin(), lenn.end(), rnd);
    for (auto len : lenn) {
        cur = string(len, '#');
        gen(0);
    }
}