Go: package main

import (
	"bufio"
	"fmt"
	"math/big"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func main() {
	sc.Scan()
	dataset, _ := strconv.Atoi(sc.Text())
	var firstdata *big.Int

	for i := 0; i < dataset*2; i++ {
		n := new(big.Int)
		sc.Scan()
		data, _ := n.SetString(sc.Text(), 10)

		if i%2 == 0 {
			firstdata = data
			continue
		}

		result := new(big.Int)
		if result := result.Add(data, firstdata); len(result.String()) > 80 {
			fmt.Println("overflow")
			continue
		} else {
			fmt.Println(result)
		}
	}
}

C++: 
#include <cmath>
#include <iostream>
#include <cstdio>
#include <ctype.h>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <iomanip>
#include <set>
#include <stack>
#include <queue>
#include <vector>
#include <sstream>


using namespace std;


string reverse(string str)
{
	string ret = "";
	
	for (int i=str.length()-1; i>=0; i--)
	{
		ret += str[i];
	}
	
	return ret;
}


/*
指定したインデックスの文字を数値に直して返す関数。
インデックスが不正な場合は数値0を返す。
*/
int new_at(string str, int index)
{
	stringstream ss;
	int ret;
	
	if (index >= str.length())
	{
		return 0;
	} else {
		ss << str[index];
		ss >> ret;
		
		return ret;
	}
}


int main()
{
	int n;
	int ia, ib;
	int flag = 0;	//繰り上がりのフラグ(繰り上がる場合は1)
	int num = 0;	//各桁の和
	
	string sa, sb;	//入力値
	string ra, rb;	//反転した入力値
	
	string sum = "";
	stringstream ss;
	int cnt;	//長いほうの文字数
	
	
	cin >> n;
	for (int i=0; i<n; i++)
	{
		cin >> sa >> sb;
		ra = reverse(sa);
		rb = reverse(sb);
		//cout << "ra = " << ra << " : rb = " << rb << endl;
		
		cnt = (ra.length() > rb.length()) ? ra.length() : sb.length();
		//cout << "cnt = " << cnt << endl;
		
		for (int j=0; j<cnt; j++)
		{
			num += new_at(ra, j) + new_at(rb, j);
			if (flag) num++;
			//cout << "(j=" << j << ") : num = " << num << endl;
			
			if (num >= 10)
			{
				num = num - 10;
				ss << num;
				sum += ss.str();
				num = 0;
				flag = 1;
			} else {
				ss << num;
				sum += ss.str();
				num = 0;
				flag = 0;
			}
			
			ss.str("");
			
			//cout << "(j=" << j << ") : sum = " << sum << endl;
		}
		
		if (flag)
		{
			sum += "1";
			flag = 0;
		}
		
		if (sum.length() > 80)
		{
			cout << "overflow" << endl;
		} else {
			//cout << "sum = " << reverse(sum) << endl;
			cout << reverse(sum) << endl;
		}
		
		sum = "";
		num = 0;
		//cout << "new_at = " << new_at(sa, 3) << endl;
		//cout << "sa = " << reverse(sa) << " : sb = " << reverse(sb) << endl;
		//cout << "sa[0] = " << sa[0] << " : sb[0] = " << sb[0] << endl;
	}
	
	return 0;
}

C++: #include <stddef.h>
#include <algorithm>
#include <iostream>
#include <iterator>
#include <string>

using namespace std;
int main() {
  int n;
  cin >> n;
  for (int i = 0; i < n; i++) {
    string s1, s2, s3 = "";
    cin >> s1 >> s2;
    size_t m = max(s1.size(), s2.size());
    while (s1.size() < m)
      s1.insert(s1.begin(), '0');
    while (s2.size() < m)
      s2.insert(s2.begin(), '0');
    char c = 0;
    auto it1 = s1.rbegin();
    auto it2 = s2.rbegin();
    for (; it1 != s1.rend(); it1++, it2++) {
      char add = *it1 - '0' + *it2 - '0' + c;
      char ch = add % 10 + '0';
      c = add / 10;
      s3.insert(s3.begin(), ch);
    }
    if (c) s3.insert(s3.begin(), c + '0');
    cout << ((s3.size() > 80) ? "overflow" :s3) << endl;
  }
}

C++: #define _USE_MATH_DEFINES
#include<iostream>
#include<string>
#include<queue>
#include<cmath>
#include<map>
#include<set>
#include<list>
#include<iomanip>
#include<vector>
#include<random>
#include<functional>
#include<algorithm>
#include<stack>
#include<cstdio>
#include<bitset>
#include<unordered_map>
#include<climits>
#include<fstream>
using namespace std;
///////////////////library zone!!!!!!!!!!!!!!!!!!!!!!!!!!!!
typedef long long ll;
typedef long double ld;
#define all(a) (a).begin(),(a).end()
#define EPS (1e-5)
const ll Mod = 1000000007;
const ll mod = 998244353;
struct H {
	ll x, y;
	bool operator<(const H &b) const {
		if (x != b.x) return x < b.x;
		return y < b.y;
	}
	bool operator>(const H &b) const {
		if (x != b.x) return x > b.x;
		return y > b.y;
	}
	bool operator==(const H &b) const { return x == b.x&&y == b.y; }
	bool operator!=(const H &b) const { return (*this) != b; }
};
struct P {
	ll pos, cost;
	bool operator<(const P &b) const { return cost < b.cost; }
	bool operator>(const P &b) const { return cost > b.cost; }
};
struct B {
	ll to, cost;
};
struct E {
	ll from, to, cost;
	bool operator<(const E &b) const { return cost < b.cost; }
	bool operator>(const E &b) const { return cost > b.cost; }
};
template<typename T, typename U>
void chmin(T &a, U b) {
	if (a > b) a = b;
}
template<typename T, typename U>
void chmax(T &a, U b) {
	if (a < b) a = b;
}
template<typename T>
T max_0(T a) {
	if (a < 0) return 0;
	return a;
}
template<typename T>
T min_0(T a) {
	if (a > 0) return 0;
	return a;
}
ll read() {
	ll u;
	ll k = scanf("%lld", &u);
	return u;
}
ll gcd(ll i, ll j) {
	if (i > j) swap(i, j);
	if (i == 0) return j;
	return gcd(j%i, i);
}
ll mod_pow(ll x, ll n, ll p) {
	ll res = 1;
	while (n > 0) {
		if (n & 1) res = res * x % p;
		x = x * x % p;
		n >>= 1;
	}
	return res;
}//x^n%p
const ll Inf = 3023372036854775807;
const int inf = 1500000000;
#define int long long
//----------------------------------------------------
class Vec2 {
public:
	ld x, y;
	Vec2() { x = 0, y = 0; }
	Vec2(ld x, ld y) :x(x), y(y) {}
	ld length() {
		return sqrt(x*x + y * y);
	}
	void normal() {
		ld len = this->length();
		if (len == 0) return;
		x /= len, y /= len;
	}
	Vec2 operator+(Vec2 vec) {
		return Vec2(x + vec.x, y + vec.y);
	}
	Vec2 operator-(Vec2 vec) {
		return Vec2(x - vec.x, y - vec.y);
	}
	Vec2 operator*(int cons) {
		return Vec2(x*cons, y*cons);
	}
	ld operator*(Vec2 vec) {
		return x * vec.x + y * vec.y;
	}
	ld operator%(Vec2 vec) {
		return x * vec.y - y * vec.x;
	}
};
ld dot(Vec2 a, Vec2 b) {
	return a.x*b.x + a.y*b.y;
}
ld cross(Vec2 a, Vec2 b) {
	return a.x*b.y - a.y*b.x;
}
ld areaIntegral(Vec2 a, Vec2 b) {
	return abs(a.x*b.y - a.y*b.x) / 2.0;
}
class Vec3 {
public:
	ld x, y, z;
	Vec3() { x = 0, y = 0, z = 0; }
	Vec3(ld x, ld y, ld z) :x(x), y(y), z(z) {}
	ld length() {
		return sqrt(x*x + y * y + z * z);
	}
	void normal() {
		ld len = this->length();
		if (len == 0) return;
		x /= len, y /= len, z /= len;
	}
	Vec3 operator+(Vec3 vec) {
		return Vec3(x + vec.x, y + vec.y, z + vec.z);
	}
	Vec3 operator-(Vec3 vec) {
		return Vec3(x - vec.x, y - vec.y, z - vec.z);
	}
	Vec3 operator*(int cons) {
		return Vec3(x*cons, y*cons, z*cons);
	}
	ld operator*(Vec3 vec) {
		return x * vec.x + y * vec.y + z * vec.z;
	}
};
ld dot(Vec3 a, Vec3 b) {
	return a.x*b.x + a.y*b.y + a.z*b.z;
}
class Line {
public:
	Vec2 from, to;
	Line(Vec2 from, Vec2 to) :from(from), to(to) {}
};
Line getPerpendicularBisector(Line line) {
	int cx = (line.from.x + line.to.x) / 2, cy = (line.from.y + line.to.y) / 2;
	Vec2 p = Vec2(cx + (line.from.y - line.to.y), cy + (line.to.x - line.from.x));
	return Line(Vec2(cx, cy), p);
}
signed main() {
	int n;
	cin >> n;
	while (n--) {
		string a, b;
		cin >> a >> b;
		for (int i = 0; i < a.size() / 2; i++) {
			swap(a[i], a[a.size() - i - 1]);
		}
		for (int i = 0; i < b.size() / 2; i++) {
			swap(b[i], b[b.size() - i - 1]);
		}
		if (a.size() > b.size()) swap(a, b);
		bool l = 0;
		string h = "";
		for (int i = 0; i < max(a.size(), b.size()); i++) {
			int k;
			if (i >= a.size()) {
				k = (int)(b[i] - ('0'));
			}
			else {
				k = (int)(a[i] - '0') + (int)(b[i] - '0');
			}
			k += l;
			l = 0;
			if (k >= 10) k -= 10, l = 1;
			h = (to_string(k) + h);
		}
		if (l) h = "1" + h;
		if (h.size() > 80) cout << "overflow\n";
		else {
			cout << h << endl;
		}
	}
}