#include <bits/stdc++.h>


using namespace std;


#ifdef zxc

#include "debug.h"

#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif

using ll = int64_t;
using ld = long double;
const ld EPS = 1e-8;
const ll MOD = 1e9 + 7;
const ld PI = 3.141592653589793;
const int maxn = 1001;

void fast_io() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
}

vector<ll> solve(vector<ll> quer) {
    vector<ll> res;
//    auto get_fi = [](ll n, ll pw_small, ll pw_big) {
//        ll row = n / 3;
//        ll fi_begin = 2 * pw_small;
//        if (row % 4 == 0) {
//            return fi_begin + row;
//        } else if (row % 4 == 1 || row % 4 == 2) {
//            return fi_begin + row + 1;
//        } else {
//            return fi_begin + row - 2;
//        }
//    };
    function<ll(ll, ll, ll)> get_corr_fi = [&](ll l, ll r, ll row) {
        if (l == r - 1) {
            return l;
        }
        ll length = (r - l) / 4;
        if (row < length) {
            return get_corr_fi(l, l + length, row % length);
        }
        if (row >= 3 * length) {
            return get_corr_fi(l + length, l + 2 * length, row % length);
        }
        if (row < 2 * length) {
            return get_corr_fi(l + 2 * length, l + 3 * length, row % length);
        }
        return get_corr_fi(l + 3 * length, l + 4 * length, row % length);
    };
    for (ll n:quer) {
        ll pw_small = 1;
        for (ll i = 2;; ++i) {
            if ((1ll << i) > n) {
                break;
            }
            if ((1ll << i) % 3 == 1) {
                pw_small = 1ll << i;
            }
        }
        n -= pw_small;
        ll ans;
        if (n % 3 == 0) {
            ans = pw_small + n / 3;
        } else if (n % 3 == 1) {
            ans = get_corr_fi(2 * pw_small, 3 * pw_small, n / 3);
        } else {
            ll zer = pw_small + n / 3;
            ll fi = get_corr_fi(2 * pw_small, 3 * pw_small, n / 3);
            ans = zer ^ fi;
        }
        res.push_back(ans);
    }
    return res;
}

vector<int> g[maxn];

int dp[maxn][2];

void dfs(int v, int p) {
    for (int to:g[v]) {
        if (to == p) {
            continue;
        }
        dfs(to, v);
    }
    dp[v][1] = 1;
    dp[v][0] = 0;
    for (int to:g[v]) {
        if (to == p) {
            continue;
        }
        dp[v][0] += max(dp[to][0], dp[to][1]);
        dp[v][1] += dp[to][0];
    }
    debug(v, dp[v][0], dp[v][1]);
}

signed main() {
#ifdef zxc
    mt19937 mt(228);
    freopen("../kolya_input.txt", "r", stdin);
//    freopen("../kolya_input.txt", "w", stdout);
#else
    mt19937 mt(std::chrono::high_resolution_clock::now().time_since_epoch().count());
//            freopen("", "r", stdin);
//        freopen("hack.out", "w", stdout);
#endif
    fast_io();
    cout.precision(10);
    cout << fixed;
    auto start = chrono::steady_clock::now();
    ll a, b, c;
    cin >> a >> b >> c;
    if (a % 2 == 0 || b % 2 == 0 || c % 2 == 0) {
        cout << 0;
        return 0;
    }
    array<ll,3> x{a,b,c};
    sort(x.begin(), x.end());
    cout<<x[0]*x[1];
    auto end = chrono::steady_clock::now();
    debug("time", chrono::duration_cast<chrono::milliseconds>(end - start).count() / 1000.0);

}



Measured memory_bytes: 256