#include <bits/stdc++.h>
using namespace std;
using lint = long long;
template<class T = int> using V = vector<T>;
template<class T = int> using VV = V< V<T> >;


struct Bint {
  bool neg;
  string s;
  Bint() : neg(false), s("0") {}
  Bint(const string& x) : neg(x[0] == '-'), s(x.substr(neg)) {}
  Bint(bool neg, const string& s) : neg(neg), s(s) {}
  Bint operator+() const { return *this; }
  Bint operator-() const { return {!neg, s}; }
  explicit operator bool() const noexcept { return s != "0"; }
  bool operator!() const noexcept { return !(bool) *this; }
  Bint operator*(const Bint& rhs) const { return Bint(*this) *= rhs; }
  Bint operator/(const Bint& rhs) const { return Bint(*this) /= rhs; }
  Bint operator%(const Bint& rhs) const { return Bint(*this) %= rhs; }
  Bint operator+(const Bint& rhs) const { return Bint(*this) += rhs; }
  Bint operator-(const Bint& rhs) const { return Bint(*this) -= rhs; }
  bool operator<(const Bint& rhs) const {
    if (neg != rhs.neg) return neg;
    return neg ^ (s.size() != rhs.s.size() ? s.size() < rhs.s.size() : s < rhs.s);
  }
  bool operator>(const Bint& rhs) const { return rhs < *this; }
  bool operator<=(const Bint& rhs) const { return !(*this > rhs); }
  bool operator>=(const Bint& rhs) const { return !(*this < rhs); }
  bool operator==(const Bint& rhs) const { return neg == rhs.neg and s == rhs.s; }
  bool operator!=(const Bint& rhs) const { return !(*this == rhs); }
  Bint& operator*=(const Bint& rhs) {
    if (!*this or !rhs) {
      neg = false, s = "0";
      return *this;
    }
    neg ^= rhs.neg;
    auto t = rhs.s;
    if (s.size() + t.size() < 20) {
      s = to_string(stoull(s) * stoull(t));
      return *this;
    }
    if (s.size() < t.size()) swap(s, t);
    int n = s.size() >> 1;
    auto s1 = s.substr(0, s.size() - n), s0 = s.substr(s.size() - n);
    if (t.size() <= n) {
      auto p1 = Bint(s1) * Bint(t);
      p1.s += string(n, '0');
      s = (p1 + Bint(s0) * Bint(t)).s;
      return *this;
    }
    auto t1 = t.substr(0, t.size() - n), t0 = t.substr(t.size() - n);
    auto p2 = Bint(s1) * Bint(t1), p0 = Bint(s0) * Bint(t0);
    auto p1 = p2 + p0 - (Bint(s1) - Bint(s0)) * (Bint(t1) - Bint(t0));
    p2.s += string(2 * n, '0'), p1.s += string(n, '0');
    s = (p2 + p1 + p0).s;
    return *this;
  }
  Bint& operator/=(const Bint& rhs) {

  }
  Bint& operator%=(const Bint& rhs) {

  }
  Bint& operator+=(const Bint& rhs) {
    auto t = rhs.s;
    reverse(begin(s), end(s));
    reverse(begin(t), end(t));
    while (s.size() < t.size()) s += '0';
    while (t.size() < s.size()) t += '0';
    s += '0', t += '0';
    if (neg == rhs.neg) {
      int c = 0;
      for (int i = 0; i < s.size(); ++i) {
        if ((s[i] += t[i] - '0' + c) > '9') {
          s[i] -= 10;
          c = 1;
        } else c = 0;
      }
    } else {
      if (neg) swap(s, t);
      s.back() = '1';
      int c = 0;
      for (int i = 0; i < s.size(); ++i) {
        if ((s[i] -= t[i] - '0' + c) < '0') {
          s[i] += 10;
          c = 1;
        } else c = 0;
      }
      if (neg = s.back() == '0') {
        int i = 0;
        while (s[i] == '0') ++i;
        s[i] = '0' + 10 - (s[i] - '0');
        while (++i < s.size() - 1) s[i] = '9' - (s[i] - '0');
      } else s.back() = '0';
    }
    while (s.size() > 1 and s.back() == '0') s.pop_back();
    reverse(begin(s), end(s));
    return *this;
  }
  Bint& operator-=(const Bint& rhs) { return *this += -rhs; }
  friend ostream& operator<<(ostream& os, const Bint& rhs) { if (rhs.neg) os << '-'; return os << rhs.s; }
  friend istream& operator>>(istream& is, Bint& rhs) { string x; is >> x; rhs = x; return is; }
};

int main() {
  cin.tie(nullptr); ios::sync_with_stdio(false);
  Bint a, b; cin >> a >> b;
  cout << a * b << '\n';
}


Measured memory_bytes: 3360