#include <bits/stdc++.h>

using namespace std;

//#define LOG(...) fprintf(stderr,__VA_ARGS__)
#define LOG(...)
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define SZ(a) ((int)(a).size())
#define BIT(x, i) (((x) >> (i)) & 1)

typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

const char cs[] = {'0', '1', '+', '-', '*', '(', ')'};
const int MAX_VAL = 1024;

int LEN;
int UNKNOWN;

int expr(string s, int& idx, bool& op);
int term(string s, int& idx, bool& op);
int factor(string s, int& idx, bool& op);
int number(string s, int& idx);

void ASSERT(bool cond, string err) {
    if (!cond) throw err;
}

void NEXT(int& idx) {
    idx++;
    ASSERT(idx < LEN, "index out of range");
}

int expr(string s, int& idx, bool& op) {
    int ret = term(s, idx, op);
    for (;;) {
        if (s[idx] == '+') {
            NEXT(idx);
            ASSERT(idx < LEN, "end of line: +");
            op = true;
            ret += term(s, idx, op);
            ASSERT(0 <= ret && ret < MAX_VAL, "number out of range");
        } else if (s[idx] == '-') {
            NEXT(idx);
            ASSERT(idx < LEN, "end of line: -");
            op = true;
            ret -= term(s, idx, op);
            ASSERT(0 <= ret && ret < MAX_VAL, "number out of range");
        } else {
            break;
        }
    }
    return ret;
}

int term(string s, int& idx, bool& op) {
    int ret = factor(s, idx, op);
    for (;;) {
        if (s[idx] == '*') {
            NEXT(idx);
            ASSERT(idx < LEN, "end of line: *");
            op = true;
            ret *= factor(s, idx, op);
            ASSERT(0 <= ret && ret < MAX_VAL, "number out of range");
        } else if (s[idx] == '(') {
            ASSERT(0, "invalid open parenthese");
        } else {
            break;
        }
    }
    return ret;
}

int factor(string s, int& idx, bool& op) {
    // ()?????????operator???????????????????????????????????????
    if (s[idx] == '(') {
        NEXT(idx);
        bool copy = op;
        op = false;
        int ret = expr(s, idx, op);
        ASSERT(op, "no operator");
        ASSERT(s[idx] == ')', "no close parenthese");
        op = copy;
        idx++;
        return ret;
    } else {
        return number(s, idx);
    }
}

int number(string s, int& idx) {
    int ret = 0;
    ASSERT(isdigit(s[idx]), "must be a number");
    while (isdigit(s[idx]) && idx < LEN) {
        ret <<= 1;
        ret |= s[idx] == '1' ? 1 : 0;
        idx++;
    }
    ASSERT(0 <= ret && ret < MAX_VAL, "number out of range");
    return ret;

}

int dfs(string s, int idx, int n) {
    if (n == UNKNOWN) {
        try {
            int idx = 0;
            bool op = false;
            LOG("%s ", s.c_str());
            int ret = expr(s, idx, op);
            LOG("= %d (idx=%d)\n", ret, idx);
            if (idx == LEN) {
                return ret;
            } else {
                return -1;
            }
            return ret;
        } catch (string e) {
            LOG("--> %s\n", e.c_str());
            return -1;
        }
    }
    int ma = -1;
    for (; idx < LEN; idx++) {
        if (s[idx] == '.') {
            for (char c : cs) {
                s[idx] = c;
                ma = max(ma, dfs(s, idx+1, n+1));
            }
        }
    }
    return ma;
}

void test(string s) {
    LEN = SZ(s);
    UNKNOWN = 0;
    REP(i, SZ(s)) if (s[i] == '.') UNKNOWN++;

    LOG("==> %s = %d\n", s.c_str(), dfs(s, 0, 0));
}

int main() {
//    test("1(");
//    test("1)");
//    test("(1.1)");
//    test("(1+(.))");

    string s;
    cin >> s;
    LEN = SZ(s);
    UNKNOWN = 0;
    REP(i, SZ(s)) if (s[i] == '.') UNKNOWN++;

    cout << dfs(s, 0, 0) << endl;
}

Measured memory_bytes: 3236