#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
using namespace std;
const int MAXN = 105;//最大位数
class HA
{//高精度数字
public:
	char data[MAXN];
	int len;
public:
	HA();
	HA(long long num);
	friend HA operator + (const HA& a, const HA& b);
	friend HA operator + (const HA& a, long long num);
	friend HA operator * (const HA& a, const HA& b);
	friend HA operator * (const HA& a, long long num);
	friend bool operator < (const HA& a, const HA& b);
	friend bool operator > (const HA& a, const HA& b);
	friend ostream& operator << (ostream& out, const HA& ha);
	friend istream& operator >> (istream& in, HA& ha);
};

HA::HA()
{
	memset(data, '0', sizeof(data));
	len = 0;
}

HA::HA(long long num)
{
	memset(data, '0', sizeof(data));
	len = 0;
	if (num == 0)
	{
		data[0] = '0';
		len = 1;
		return;
	}
	while (num)
	{
		data[len++] = num % 10 + 48;
		num /= 10;
	}
}


HA operator + (const HA& a, const HA& b)
{
	HA c;
	int maxlen = max(a.len, b.len);
	int* numa = (int*)calloc(maxlen, sizeof(int));
	int* numb = (int*)calloc(maxlen, sizeof(int));
	int* numc = (int*)calloc(maxlen + 1, sizeof(int));
	for (int i = 0; i < maxlen; i++)
	{
		numa[i] = a.data[i] - 48;
	}
	for (int i = 0; i < maxlen; i++)
	{
		numb[i] = b.data[i] - 48;
	}
	for (int i = 0; i < maxlen; i++)
	{
		numc[i] += numa[i] + numb[i];
		if (numc[i] >= 10)
		{
			numc[i + 1] += numc[i] / 10;
			numc[i] %= 10;
		}
	}
	for (int i = 0; i <= maxlen; i++)
	{
		c.data[i] += numc[i];
	}
	c.len = 1;
	for (int i = maxlen; i >= 0; i--)
	{
		if (c.data[i] != '0')
		{
			c.len = i + 1;
			break;
		}
	}

	return c;
}

HA operator + (const HA& a, long long num)
{
	HA b = num;
	return a + b;
}

HA operator * (const HA& a, const HA& b)
{
	HA c;
	int* numa = (int*)calloc(a.len, sizeof(int));
	int* numb = (int*)calloc(b.len, sizeof(int));
	int* numc = (int*)calloc(a.len + b.len, sizeof(int));
	for (int i = 0; i < a.len; i++)
	{
		numa[i] = a.data[i] - 48;
	}
	for (int i = 0; i < b.len; i++)
	{
		numb[i] = b.data[i] - 48;
	}
	for (int i = 0; i < a.len; i++)
	{
		for (int j = 0; j < b.len; j++)
		{
			numc[i + j] += numa[i] * numb[j];
			if (numc[i + j] >= 10)
			{
				numc[i + j + 1] += numc[i + j] / 10;
				numc[i + j] %= 10;
			}
		}
	}
	for (int i = 0; i < a.len + b.len; i++)
	{
		c.data[i] += numc[i];
	}
	c.len = 1;
	for (int i = a.len + b.len - 1; i >= 0; i--)
	{
		if (c.data[i] != '0')
		{
			c.len = i + 1;
			break;
		}
	}
	free(numa);
	free(numb);
	free(numc);
	return c;
}

HA operator * (const HA& a, long long num)
{
	HA b = num;
	return a * b;
}

bool operator < (const HA& a, const HA& b)
{
	if (a.len == b.len)
	{
		for (int i = a.len - 1; i >= 0; i--)
		{
			if (a.data[i] != b.data[i])
			{
				return a.data[i] < b.data[i];
			}
		}
		return 0;
	}
	else
	{
		return a.len < b.len;
	}
}

bool operator < (const HA& a, long long num)
{
	HA b = num;
	if (a.len == b.len)
	{
		for (int i = a.len - 1; i >= 0; i--)
		{
			if (a.data[i] != b.data[i])
			{
				return a.data[i] < b.data[i];
			}
		}
		return 0;
	}
	else
	{
		return a.len < b.len;
	}
}

bool operator < (long long num, const HA& b)
{
	HA a = num;
	if (a.len == b.len)
	{
		for (int i = a.len - 1; i >= 0; i--)
		{
			if (a.data[i] != b.data[i])
			{
				return a.data[i] < b.data[i];
			}
		}
		return 0;
	}
	else
	{
		return a.len < b.len;
	}
}

bool operator > (const HA& a, const HA& b)
{
	if (a.len == b.len)
	{
		for (int i = a.len - 1; i >= 0; i--)
		{
			if (a.data[i] != b.data[i])
			{
				return a.data[i] > b.data[i];
			}
		}
		return 0;
	}
	else
	{
		return a.len > b.len;
	}
}

bool operator > (const HA& a, long long num)
{
	HA b = num;
	if (a.len == b.len)
	{
		for (int i = a.len - 1; i >= 0; i--)
		{
			if (a.data[i] != b.data[i])
			{
				return a.data[i] > b.data[i];
			}
		}
		return 0;
	}
	else
	{
		return a.len > b.len;
	}
}

bool operator > (long long num, const HA& b)
{
	HA a = num;
	if (a.len == b.len)
	{
		for (int i = a.len - 1; i >= 0; i--)
		{
			if (a.data[i] != b.data[i])
			{
				return a.data[i] > b.data[i];
			}
		}
		return 0;
	}
	else
	{
		return a.len > b.len;
	}
}

ostream& operator << (ostream& out, const HA& ha)
{
	for (int i = ha.len - 1; i >= 0; i--)
	{
		out << ha.data[i];
	}
	return out;
}

istream& operator >> (istream& in, HA& ha)
{
	memset(ha.data, '0', sizeof(ha.data));
	ha.len = 0;
	char tmp[MAXN];
	in >> tmp;
	int len = strlen(tmp);
	for (int i = len - 1; i >= 0; i--)
	{
		ha.data[ha.len++] = tmp[i];
	}
	if (ha.len == 1 && ha.data[0] == '0')
	{
		ha.len = 1;
	}
	return in;
}

const HA& max(const HA& a, const HA& b)
{
	return a > b ? a : b;
}

const HA& max(long long num, const HA& b)
{
	const HA& a = num;
	return a > b ? a : b;
}

int main()
{
	HA a, b;
	while (1)
	{
		cin >> a >> b;
		cout << a + b << endl;
		cout << a * b << endl;
	}
	return 0;
}