#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int (i)=(0);(i)<(int)(n);++(i))
using ll = long long;
using P = pair<int, int>;
using namespace std;

// 構文解析
using State = string::const_iterator;
class ParseError{};

ll number(State &begin);
ll term(State &begin, char op1, char op2, char op3);
ll term2(State &begin, char op1, char op2, char op3);
ll factor(State &begin, char op1, char op2, char op3);
ll expression(State &begin, char op1, char op2, char op3);
void consume(State &begin, char ch);

ll expression_two(State &begin, string op1, char op2);
ll term_two(State &begin, string op1, char op2);
ll factor_two(State &begin, string op1, char op2);

ll expression_two2(State &begin, char op1, string op2);
ll term_two2(State &begin, char op1, string op2);
ll factor_two2(State &begin, char op1, string op2);

ll expression_three(State &begin);
ll term_three(State &begin);
ll factor_three(State &begin);

ll expression_three(State &begin) {
    ll ret = factor_three(begin);

    for (;;) {
        if (*begin == '+') {
            ++begin;
            ret += factor_three(begin);
        }
        else if (*begin == '-') {
            ++begin;
            ret -= factor_three(begin);
        }
        else if (*begin == '*') {
            ++begin;
            ret *= factor_three(begin);
        }
        else {
            break;
        }
    }

    return ret;
}

ll factor_three(State &begin) {
    if (*begin == '(') {
        begin++; // '('を飛ばす
        ll ret = expression_three(begin);
        begin++;
        return ret;
    }
    else {
        return number(begin);
    }
}

// 数字の列をパースして，その数を返す
ll number(State &begin) {
    ll ret = 0;

    while (isdigit(*begin)) {
        ret *= 10LL;
        ret += *begin - '0';
        begin++;
    }

    return ret;
}


ll term(State  &begin, char op1, char op2, char op3) {
    ll ret = term2(begin, op1, op2, op3);

    for (;;) {
        if (*begin == op2) {
            begin++;
            if (op2 == '+') {
                ret += term2(begin, op1, op2, op3);
            }
            else if (op2 == '-') {
                ret -= term2(begin, op1, op2, op3);
            }
            else {
                ret *= term2(begin, op1, op2, op3);
            }
        }
        else {
            break;
        }
    }

    return ret;
}

// 乗算除算の式をパースして，その評価結果を返す
ll term2(State &begin, char op1, char op2, char op3) {
    ll ret = factor(begin, op1, op2, op3);

    for (;;) {
        if (*begin == op3) {
            begin++;
            if (op3 == '+') {
                ret += factor(begin, op1, op2, op3);
            }
            else if (op3 == '-') {
                ret -= factor(begin, op1, op2, op3);
            }
            else {
                ret *= factor(begin, op1, op2, op3);
            }
        }
        else {
            break;
        }
    }

    return ret;
}

ll factor(State &begin, char op1, char op2, char op3) {
    if (*begin == '(') {
        begin++; // '('を飛ばす
        ll ret = expression(begin, op1, op2, op3);
        begin++;
        return ret;
    }
    else {
        return number(begin);
    }
}


// 四則演算の式をパースして，その評価結果を返す
ll expression(State &begin, char op1, char op2, char op3) {
    ll ret = term(begin, op1, op2, op3);

    for (;;) {
        if (*begin == op1) {
            begin++;
            if (op1 == '+') {
                ret += term(begin, op1, op2, op3);
            }
            else if (op1 == '-') {
                ret -= term(begin, op1, op2, op3);
            }
            else {
                ret *= term(begin, op1, op2, op3);
            }
        }
        else {
            break;
        }
    }

    return ret;
}

ll expression_two(State &begin, string op1, char op2) {
    ll ret = term_two(begin, op1, op2);

    for (;;) {
        if (*begin == op1[0]) {
            begin++;
            if (op1[0] == '+') {
                ret += term_two(begin, op1, op2);
            }
            else if (op1[0] == '-') {
                ret -= term_two(begin, op1, op2);
            }
            else {
                ret *= term_two(begin, op1, op2);
            }
        }
        else if (*begin == op1[1]) {
            begin++;
            if (op1[1] == '+') {
                ret += term_two(begin, op1, op2);
            }
            else if (op1[1] == '-') {
                ret -= term_two(begin, op1, op2);
            }
            else {
                ret *= term_two(begin, op1, op2);
            }
        }
        else {
            break;
        }
    }

    return ret;
}

ll term_two(State &begin, string op1, char op2) {
    ll ret = factor_two(begin, op1, op2);

    for (;;) {
        if (*begin == op2) {
            begin++;
            if (op2 == '+') {
                ret += factor_two(begin, op1, op2);
            }
            else if (op2 == '-') {
                ret -= factor_two(begin, op1, op2);
            }
            else {
                ret *= factor_two(begin, op1, op2);
            }
        }
        else {
            break;
        }
    }

    return ret;
}

ll factor_two(State &begin, string op1, char op2) {
    if (*begin == '(') {
        begin++; // '('を飛ばす
        ll ret = expression_two(begin, op1, op2);
        begin++;
        return ret;
    }
    else {
        return number(begin);
    }
}


ll expression_two2(State &begin, char op1, string op2) {
    ll ret = term_two2(begin, op1, op2);

    for (;;) {
        if (*begin == op1) {
            begin++;
            if (op1 == '+') {
                ret += term_two2(begin, op1, op2);
            }
            else if (op1 == '-') {
                ret -= term_two2(begin, op1, op2);
            }
            else {
                ret *= term_two2(begin, op1, op2);
            }
        }
        else {
            break;
        }
    }

    return ret;
}


ll term_two2(State &begin, char op1, string op2) {
    ll ret = factor_two2(begin, op1, op2);

    for (;;) {
        if (*begin == op2[0]) {
            begin++;
            if (op2[0] == '+') {
                ret += factor_two2(begin, op1, op2);
            }
            else if (op2[0] == '-') {
                ret -= factor_two2(begin, op1, op2);
            }
            else {
                ret *= factor_two2(begin, op1, op2);
            }
        }
        else if (*begin == op2[1]) {
            ++begin;
            if (op2[1] == '+') {
                ret += factor_two2(begin, op1, op2);
            }
            else if (op2[1] == '-') {
                ret -= factor_two2(begin, op1, op2);
            }
            else {
                ret *= factor_two2(begin, op1, op2);
            }
        }
        else {
            break;
        }
    }

    return ret;
}

ll factor_two2(State &begin, char op1, string op2) {
    if (*begin == '(') {
        begin++; // '('を飛ばす
        ll ret = expression_two2(begin, op1, op2);
        begin++;
        return ret;
    }
    else {
        return number(begin);
    }
}

void consume(State &begin, char expected) {
    if (*begin == expected) {
        begin++;
    }
    else {
        cerr << "Expected " << expected << " but got " << *begin << endl;
        cerr << "Rest string is ";
        while (*begin) {
            cerr << *begin++;
        }
        cerr << endl;
        throw ParseError();
    }
}

int main() {
    string s;
    getline(cin, s);

    // 1つだけ選択
    State begin = s.begin();
    ll ret = expression_three(begin);

    string tmp = "+-*";
    rep(i, 3) rep(j, 3) {
        if (i == j) continue;
        rep(k, 3) {
            if (i == k or j == k) continue;
            char op1 = tmp[i];
            char op2 = tmp[j];
            char op3 = tmp[k];
            State begin = s.begin();
            ll ans = expression(begin, op1, op2, op3);
            ret = max(ret, ans);
        }
    }
    //
    // 前に2つ選択
    rep(i, 3) rep(j, 3) {
        if (i == j) continue;
        rep(k, 3) {
            if (i == k or j == k) continue;
            char op1 = tmp[i];
            char op2 = tmp[j];
            char op3 = tmp[k];
            string OP1 = "" + string(1, op1) + string(1, op2);
            State begin = s.begin();
            ll ans = expression_two(begin, OP1, op3);
            ret = max(ret, ans);
        }
    }

    // 後ろに2つ
    rep(i, 3) rep(j, 3) {
        if (i == j) continue;
        rep(k, 3) {
            if (i == k or j == k) continue;
            char op1 = tmp[i];
            char op2 = tmp[j];
            char op3 = tmp[k];
            string OP2 = string(1, op2) + string(1, op3);
            State begin = s.begin();
            ll ans = expression_two2(begin, op1, OP2);
            ret = max(ret, ans);
        }
    }

    cout << ret << endl;
    return 0;
}



Measured memory_bytes: 3228