#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void reverse_string(char *str) {
    int len = strlen(str);
    int i = 0, j = len - 1;
    char temp;
    while (i < j) {
        temp = str[i];
        str[i] = str[j];
        str[j] = temp;
        i++;
        j--;
    }
}

int main() {
    char a_str[1002];
    char b_str[1002];
    scanf("%s", a_str);
    scanf("%s", b_str);

    if (strcmp(a_str, "0") == 0 || strcmp(b_str, "0") == 0) {
        printf("0\n");
        return 0;
    }

    int len_a = strlen(a_str);
    int len_b = strlen(b_str);

    // Mảng kết quả. Kích thước tối đa là len_a + len_b
    int *result = (int*)calloc(len_a + len_b + 2, sizeof(int));

    // Đảo ngược chuỗi để thực hiện phép nhân từ chữ số cuối (units) đến đầu
    reverse_string(a_str);
    reverse_string(b_str);

    // Nhân từng chữ số và cộng vào vị trí tương ứng
    for (int i = 0; i < len_a; i++) {
        for (int j = 0; j < len_b; j++) {
            int digit_a = a_str[i] - '0';
            int digit_b = b_str[j] - '0';
            result[i + j] += digit_a * digit_b;
        }
    }

    // Xử lý số nhớ
    int carry = 0;
    for (int i = 0; i < len_a + len_b; i++) {
        int sum = result[i] + carry;
        result[i] = sum % 10;
        carry = sum / 10;
    }

    // Tìm độ dài thực tế của kết quả (loại bỏ số 0 ở đầu)
    int res_len = len_a + len_b;
    while (res_len > 0 && result[res_len - 1] == 0) {
        res_len--;
    }

    // In kết quả (đảo ngược lại)
    for (int i = res_len - 1; i >= 0; i--) {
        printf("%d", result[i]);
    }
    printf("\n");

    free(result);
    return 0;
}

// Đây là pseudo-code minh họa logic Karatsuba
// Để implement đầy đủ cần các hàm cộng/trừ/nhân chuỗi hỗ trợ
#include <stdio.h>
#include <string.h>

// Hàm cộng hai chuỗi số lớn
char* add(char* a, char* b);
// Hàm trừ hai chuỗi số lớn
char* sub(char* a, char* b);
// Hàm nhân hai chuỗi số lớn (dùng cho các phần nhỏ hơn)
char* multiply(char* a, char* b);

char* karatsuba(char* x, char* y) {
    int n = strlen(x);
    int m = strlen(y);

    // Cơ sở: nếu số nhỏ, dùng phép nhân thường O(1)
    if (n < 10 || m < 10) {
        // Chuyển sang số nguyên, nhân, rồi chuyển về chuỗi
        // ... code chuyển đổi ...
        return result;
    }

    int half = (n > m ? n : m) / 2;

    // Chia a và b thành 2 phần
    // ... code chia chuỗi ...
    char *high1, *low1, *high2, *low2;

    // z0 = low1 * low2
    char *z0 = karatsuba(low1, low2);
    // z2 = high1 * high2
    char *z2 = karatsuba(high1, high2);
    // z1 = (high1 + low1) * (high2 + low2) - z2 - z0
    char *sum1 = add(high1, low1);
    char *sum2 = add(high2, low2);
    char *z1 = multiply(sum1, sum2);
    z1 = sub(z1, z2);
    z1 = sub(z1, z0);

    // Kết quả = z2 * 10^(2m) + z1 * 10^m + z0
    // ... code dịch trái (thêm số 0) và cộng ...

    return result;
}

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <iomanip>

using namespace std;

// Trong C++, các ngôn ngữ hiện đại khác (Java, Python) có hỗ trợ sẵn BigInt.
// Nếu làm thủ công trong C++, ta có thể dùng struct hoặc class.
// Đây là ví dụ về cách dùng algorithm base 10000 hoặc 10^9 để tối ưu.

const int BASE = 1000000000;

struct BigInt {
    vector<long long> digits;
    bool is_neg;

    BigInt(string s = "0") {
        if (s[0] == '-') { is_neg = true; s = s.substr(1); }
        else is_neg = false;

        for (int i = s.length(); i > 0; i -= 9) {
            if (i < 9)
                digits.push_back(stoll(s.substr(0, i)));
            else
                digits.push_back(stoll(s.substr(i - 9, 9)));
        }
        trim();
    }

    void trim() {
        while (digits.size() > 1 && digits.back() == 0) {
            digits.pop_back();
        }
        if (digits.size() == 1 && digits[0] == 0) is_neg = false;
    }

    // ... Các toán tử cộng, trừ ...

    BigInt operator*(const BigInt& other) const {
        // Implement O(N^2) multiplication
        BigInt res;
        res.digits.resize(digits.size() + other.digits.size(), 0);
        for (size_t i = 0; i < digits.size(); i++) {
            long long carry = 0;
            for (size_t j = 0; j < other.digits.size() || carry; j++) {
                long long cur = res.digits[i+j] + digits[i] * (j < other.digits.size() ? other.digits[j] : 0) + carry;
                res.digits[i+j] = cur % BASE;
                carry = cur / BASE;
            }
        }
        res.is_neg = is_neg ^ other.is_neg;
        res.trim();
        return res;
    }
};

int main() {
    string s1, s2;
    cin >> s1 >> s2;
    BigInt a(s1), b(s2);
    BigInt c = a * b;

    if (c.digits.empty()) cout << 0;
    else {
        if (c.is_neg) cout << '-';
        cout << c.digits.back();
        for (int i = c.digits.size() - 2; i >= 0; i--) {
            cout << setfill('0') << setw(9) << c.digits[i];
        }
    }
    cout << endl;
}