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

using ll = long long;
using ld = long double;

#define len(a) int((a).size())
#define all(a) begin(a), end(a)
#define rep(i, n) for (int i = 0; i < (n); i++)

enum class OPERATION {
    PLUS,
    MINUS,
    DIV,
    MUL,
    SIN,
    COS,
    X,
};

struct node {
    OPERATION op;
    array<int, 2> childs;
    int size = 0, hsh = -1;

    node() {
        op = OPERATION::X;
        childs = { -1, -1 };
    }
};

map<pair<OPERATION, pair<int, int>>, int> mp;
vector<node> tree;

int new_node() {
    tree.push_back(node());
    return len(tree) - 1;
}

ld eval(int v, ld x) {
    if (tree[v].op == OPERATION::X) {
        return x;
    } else if (tree[v].op == OPERATION::PLUS) {
        return eval(tree[v].childs[0], x) + eval(tree[v].childs[1], x);
    } else if (tree[v].op == OPERATION::MINUS) {
        return eval(tree[v].childs[0], x) - eval(tree[v].childs[1], x);
    } else if (tree[v].op == OPERATION::MUL) {
        return eval(tree[v].childs[0], x) * eval(tree[v].childs[1], x);
    } else if (tree[v].op == OPERATION::DIV) {
        auto right = eval(tree[v].childs[1], x);
        if (fabs(right) < 0.01) {
            return rand();
        }
        return eval(tree[v].childs[0], x) / right;
    } else if (tree[v].op == OPERATION::COS) {
        return cosl(eval(tree[v].childs[0], x));
    } else if (tree[v].op == OPERATION::SIN) {
        return sinl(eval(tree[v].childs[0], x));
    } else {
        assert(false);
    }
}

string build(int v) {
    if (tree[v].op == OPERATION::X) {
        return "x";
    } else if (tree[v].op == OPERATION::PLUS) {
        return "(" + build(tree[v].childs[0]) + ")+(" + build(tree[v].childs[1]) + ")";
    } else if (tree[v].op == OPERATION::MINUS) {
        return "(" + build(tree[v].childs[0]) + ")-(" + build(tree[v].childs[1]) + ")";
    } else if (tree[v].op == OPERATION::MUL) {
        return "(" + build(tree[v].childs[0]) + ")*(" + build(tree[v].childs[1]) + ")";
    } else if (tree[v].op == OPERATION::DIV) {
        return "(" + build(tree[v].childs[0]) + ")/(" + build(tree[v].childs[1]) + ")";
    } else if (tree[v].op == OPERATION::COS) {
        return "cos(" + build(tree[v].childs[0]) + ")";
    } else if (tree[v].op == OPERATION::SIN) {
        return "sin(" + build(tree[v].childs[0]) + ")";
    } else {
        assert(false);
    }
}

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    cout << fixed << setprecision(10);

    int root = new_node();
    for (int it = 0; it < 9; it++) {
        // cout << it << endl;

        vector<int> ord(len(tree));
        iota(all(ord), 0);
        sort(all(ord), [&](int i, int j) {
            return tree[i].size < tree[j].size;
            });

        const int N = len(tree);
        for (auto v : ord) {
            for (auto u : ord) {
                int nsize = tree[v].size + tree[u].size + 2;
                if (nsize > 9) {
                    break;
                }

                for (auto op : { OPERATION::PLUS, OPERATION::MINUS, OPERATION::DIV, OPERATION::MUL }) {
                    pair<int, int> c = { tree[v].hsh, tree[u].hsh };
                    if (op == OPERATION::PLUS || op == OPERATION::MUL) {
                        if (c.first > c.second) {
                            swap(c.first, c.second);
                        }
                    }
                    auto it = mp.find(make_pair(op, c));
                    if (it != mp.end()) {
                        continue;
                    }

                    int cur_hash = len(mp);
                    mp[make_pair(op, c)] = cur_hash;
                    int w = new_node();
                    tree[w].op = op;
                    tree[w].childs = { v, u };
                    tree[w].hsh = cur_hash;
                    tree[w].size = nsize;
                }
            }

            for (auto op : { OPERATION::COS, OPERATION::SIN }) {
                int nsize = tree[v].size + 1;
                if (nsize > 9) {
                    continue;
                }

                auto it = mp.find(make_pair(op, pair<int, int>{tree[v].hsh, -1}));
                if (it != mp.end()) {
                    continue;
                }

                int cur_hash = len(mp);
                mp[make_pair(op, pair<int, int>{tree[v].hsh, -1})] = cur_hash;
                int w = new_node();
                tree[w].op = op;
                tree[w].childs = { v, -1 };
                tree[w].hsh = cur_hash;
                tree[w].size = nsize;
            }
        }
        // cout << len(tree) << endl;
    }

    int n;
    cin >> n;
    vector<ld> x(n), y(n);
    for (int i = 0; i < n; i++) {
        cin >> x[i] >> y[i];
    }

    for (int v = 0; v < len(tree); v++) {
        bool fail = false;
        for (int i = 0; i < n; i++) {
            if (fabs(eval(v, x[i]) - y[i]) > 1e-6) {
                fail = true;
                break;
            }
        }

        if (fail) {
            continue;
        }
        cout << build(v) << '\n';
        return 0;
    }
    assert(false);
}