#include <bits/stdc++.h>
const int __SETW__ = 6;
using std::cin;
using std::cout;
using std::endl;
using INT = long long int;
const INT INF = INT(1) << 60;
using VEC = std::vector<INT>;
using VECVEC = std::vector<VEC>;
using VECVECVEC = std::vector<VEC>;
template <class T>
T safe_get(const std::vector<T>& v, INT idx, T def = -1) {
  if (idx < 0 || v.size() <= idx) {
    return def;
  } else {
    return v[idx];
  }
}
template <class T>
T safe_get(const std::vector<std::vector<T> >& vv, INT idx1, INT idx2,
           T def = -1) {
  if (idx1 < 0 || vv.size() <= idx1) {
    return def;
  } else {
    return safe_get(vv[idx1], idx2, def);
  }
}
template <class T, class F>
inline bool ANY(T sequence, F func) {
  for (auto&& t : sequence) {
    if (func(t)) {
      return true;
    }
  }
  return false;
}
template <class T, class F>
inline bool ALL(T sequence, F func) {
  for (auto&& t : sequence) {
    if (!func(t)) {
      return false;
    }
  }
  return true;
}
template <class T>
std::ostream& operator<<(std::ostream& lhs, const std::priority_queue<T>& rhs) {
  std::queue<T> copy = rhs;
  while (!copy.empty()) {
    lhs << std::setw(__SETW__) << copy.front() << " ";
    copy.pop();
  }
  return lhs;
}
template <class T>
std::ostream& operator<<(std::ostream& lhs, const std::queue<T>& rhs) {
  std::queue<T> copy = rhs;
  while (!copy.empty()) {
    lhs << std::setw(__SETW__) << copy.front() << " ";
    copy.pop();
  }
  return lhs;
}
template <class T>
std::ostream& operator<<(std::ostream& lhs, const std::stack<T>& rhs) {
  std::stack<T> copy = rhs;
  while (!copy.empty()) {
    lhs << std::setw(__SETW__) << copy.top() << " ";
    copy.pop();
  }
  return lhs;
}
template <class T>
std::ostream& operator<<(std::ostream& lhs,
                         const std::vector<std::vector<T> >& rhs) {
  for (auto&& v : rhs) {
    lhs << v << endl;
  }
  return lhs;
}
template <class T>
std::ostream& operator<<(std::ostream& lhs, const std::vector<T>& rhs) {
  for (auto&& t : rhs) {
    lhs << std::setw(__SETW__) << t << " ";
  }
  return lhs;
}
template <class T>
std::ostream& operator<<(std::ostream& lhs, const std::list<T>& rhs) {
  for (auto&& t : rhs) {
    lhs << std::setw(__SETW__) << t << " ";
  }
  return lhs;
}
template <class T1, class T2>
std::ostream& operator<<(std::ostream& lhs, const std::map<T1, T2>& rhs) {
  for (auto&& m : rhs) {
    lhs << std::setw(__SETW__) << m.first << ":" << std::setw(__SETW__)
        << m.second << endl;
  }
  return lhs;
}
template <class T1, class T2>
std::ostream& operator<<(std::ostream& lhs, const std::multimap<T1, T2>& rhs) {
  for (auto&& m : rhs) {
    lhs << std::setw(__SETW__) << m.first << ":" << std::setw(__SETW__)
        << m.second << endl;
  }
  return lhs;
}
template <class T>
std::ostream& operator<<(std::ostream& lhs, const std::set<T>& rhs) {
  for (auto&& t : rhs) {
    lhs << std::setw(__SETW__) << t << " ";
  }
  return lhs;
}
template <class T>
std::ostream& operator<<(std::ostream& lhs, const std::multiset<T>& rhs) {
  for (auto&& t : rhs) {
    lhs << std::setw(__SETW__) << t << " ";
  }
  return lhs;
}
template <class T>
std::ostream& operator<<(std::ostream& lhs, const std::complex<T>& rhs) {
  std::streamsize ss = lhs.precision();
  lhs << "(" << std::setw(5) << std::setprecision(4) << rhs.real() << ","
      << std::setw(5) << std::setprecision(4) << rhs.imag() << ") ";
  lhs.precision(ss);
  return lhs;
}
template <class T1, class T2>
std::ostream& operator<<(std::ostream& lhs, const std::pair<T1, T2>& rhs) {
  lhs << "(" << rhs.first << "," << rhs.second << ")";
  return lhs;
}
template <class T>
T chmax(T& lhs, const T& rhs) {
  lhs = std::max(lhs, rhs);
  return lhs;
}
template <class T>
T chmin(T& lhs, const T& rhs) {
  lhs = std::min(lhs, rhs);
  return lhs;
}
using namespace std;
int main() {
  INT A, B;
  if (A > 9 || B > 9) {
    cout << -1 << endl;
  } else {
    cout << A * B << endl;
  }
  return 0;
}
