#include <bits/stdc++.h>
using namespace std;
using ll = long long;

struct bigfloat
{
    string inp; // 整数部分
    string flp; // 小数部分
    bigfloat(string s)
    {
        size_t itr = s.find('.');
        if(itr != string::npos)
        {
            inp = rm_zero_inp(s.substr(0, itr));
            flp = rm_zero_flp(s.substr(itr+1, s.length()));
        }
        else
        {
            inp = rm_zero_inp(s);
            flp = "";
        }
    }
    bigfloat& operator+=(bigfloat bf)
    {
        string nflp(max(flp.length(), bf.flp.length()), '0');
        int np = 0;
        for(ll i=nflp.length()-1; i>=0; i--)
        {
            int op = np;
            if(i<flp.length()) op += flp.at(i) - '0';
            if(i<bf.flp.length()) op += bf.flp.at(i) - '0';
            np = op/10;
            op %= 10;
            nflp.at(i) = op + '0';
        }
        flp = rm_zero_flp(nflp);

        string ninp(max(inp.length(), bf.inp.length()) + 1, '0');
        for(ll i=ninp.length()-1; i>=0; i--)
        {
            int op = np;
            if(!inp.empty())
            {
                op += inp.at(inp.length()-1) - '0';
                inp.erase(inp.length() - 1);
            }
            if(!bf.inp.empty())
            {
                op += bf.inp.at(bf.inp.length()-1) - '0';
                bf.inp.erase(bf.inp.length() - 1);
            }
            np = op/10;
            op %= 10;
            ninp.at(i) = op + '0';
        }
        inp = rm_zero_inp(ninp);

        return *this;
    }
    bigfloat& operator*=(const bigfloat bf)
    {
        bigfloat nbf("0.0");
        string s = inp + flp;
        string bs = bf.inp + bf.flp;
        ll decimal = flp.length() + bf.flp.length();
        for(ll i=0, len=bs.length(); i<len; i++)
        {
            int num = bs.at(bs.length() - 1) - '0';
            bs.erase(bs.length() - 1);
            string ls(i, '0');
            int np = 0;
            for(ll j=s.length()-1; j>=0; j--)
            {
                int op = s.at(j) - '0';
                op *= num;
                op += np;
                np = op/10;
                op %= 10;
                ls.insert(ls.begin(), op + '0');
            }
            if(np != 0) ls.insert(ls.begin(), np + '0');
            nbf += bigfloat(ls);
        }
        for(int i=0; nbf.inp.length() < decimal; i++)
        {
            nbf.inp.insert(nbf.inp.begin(), '0');
        }
        inp = rm_zero_inp(nbf.inp.substr(0, nbf.inp.length() - decimal));
        flp = rm_zero_flp(nbf.inp.substr(nbf.inp.length() - decimal, nbf.inp.length()));
        return *this;
    }
    string rm_zero_inp(string s)
    {
        ll itr = -1;
        for(ll i=0; i<s.length(); i++)
        {
            if(s.at(i) != '0')
            {
                itr = i;
                break;
            }
        }
        s.erase(0, itr);
        return s;
    }
    string rm_zero_flp(string s)
    {
        ll itr = -1;
        for(ll i=s.length()-1; i>=0; i--)
        {
            if(s.at(i) != '0')
            {
                itr = i;
                break;
            }
        }
        s.erase(itr+1);
        return s;
    }
};
ostream &operator<<(ostream &os, const bigfloat &bf)
{
    if(bf.inp.empty()) return os << "0";
    else return os << bf.inp;
    // if(bf.inp.empty() && bf.flp.empty()) return os << "0";
    // else if(bf.flp.empty()) return os << bf.inp;
    // else if(bf.inp.empty()) return os << '.' << bf.flp;
    // else return os << bf.inp << '.' << bf.flp;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    string a;
    string b;
    cin >> a >> b;
    bigfloat bfa(a);
    bigfloat bfb(b);
    bfa *= bfb;
    cout << bfa << '\n';

    return 0;
}


Measured memory_bytes: 3656