Go: package main

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

var scanner = bufio.NewScanner(os.Stdin)

func nextString() string {
	scanner.Scan()
	return scanner.Text()
}

func nextInt() int {
	n, err := strconv.Atoi(nextString())
	if err != nil {
		fmt.Printf("strconv.Atoi failed: %v\n", err)
	}
	return n
}

func main() {
	scanner.Split(bufio.ScanWords)

	const maxCapacity = 512 * 1024
	buf := make([]byte, maxCapacity)
	scanner.Buffer(buf, maxCapacity)

	n := nextInt()
	maxint, _ := new(big.Int).SetString("100000000000000000000000000000000000000000000000000000000000000000000000000000000", 10)

	for i := 0; i < n; i++ {
		aStr := nextString()
		bStr := nextString()

		a, _ := new(big.Int).SetString(aStr, 10)
		b, _ := new(big.Int).SetString(bStr, 10)
		c := big.NewInt(0).Add(a, b)

		if c.Cmp(maxint) < 0 {
			fmt.Println(c)
		} else {
			fmt.Println("overflow")
		}
	}
}

C++: //#define _GRIBCXX_DEBUG
#include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <iomanip>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;


// ?????¬???????????¬??????
#pragma region MACRO
#define P(x) cout << (x) << endl
#define p(x) cout << (x)
#define PED cout << "\n"
#define rep(i,n) for(int i=0; i<(int)n; ++i)
#define REP(i,x,n) for(int i=x; i<(int)n; ++i)
#define repi(i,n) for(int i=0; i<=(int)n; ++i)
#define REPI(i,x,n) for(int i=x; i<=(int)n; ++i)
#define ILP while(true)
#define FOR(i,c) for(__typeof((c).begin())!=(c).begin(); i!=(c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define mp make_pair
#pragma endregion

// ???
#pragma region TYPE_DEF
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<string, string> pss;
typedef pair<string, int> psi;
typedef pair<int, string> pis;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<long> vl;
typedef vector<long long> vll;
typedef vector<string> vs;
#pragma endregion

// Effective std
#pragma region ESTD
template<typename C, typename T>
constexpr int count(C& c, T t) { return count(ALL(c), t); }
template<typename C, typename F>
constexpr int count_if(C& c, F f) { return count_if(ALL(c), f); }
template<typename C, typename T>
void erase(C& c, T t) { remove(ALL(c), t), c.end(); }
template<typename C>
void remove(vector<C>& c, unsigned int index) { c.erase(c.begin()+index); }
template<typename C, typename T, typename U>
constexpr void replace(C& c, T t, U u) { replace(ALL(c), t, u); }
template<typename C, typename F, typename U>
constexpr void replace_if(C& c, F f, U u) { (ALL(c), f, u); }
template<typename C>
constexpr void reverse(C& c) { reverse(ALL(c)); }
template<typename C>
constexpr void sort(C& c) { sort(ALL(c)); }
template<typename C, typename Pred>
constexpr void sort(C& c, Pred p) { sort(ALL(c), p); }
#pragma endregion

// ?????°
#pragma region CONST_VAL
#define PI (2*acos(0.0))
#define EPS (1e-9)
#define MOD (int)(1e9+7)
#pragma endregion


int main()
{
    int n; cin>>n;
    rep(i,n*2) {
        string a,b; cin>>a>>b;
        if(a.size()>80||b.size()>80) P("overflow");
        string c = to_string(stoi(a) + stoi(b));
        if(c.size()>80) P("overflow");
        P(c);
    }
    return 0;
}

C++: #include "bits/stdc++.h"

#define debug(x) cout<<#x<<": "<<x<<endl
#define rep(i,n) for (int i=0;i<(n);i++)
#define FOR(i,a,b) for (int i=(a);i<=(b);i++)
#define all(a) (a).begin(),(a).end()
using namespace std;
typedef vector<int> VI;
typedef vector<vector<int>> VVI;
typedef long long ll;

void solve() {
#ifdef _WIN32
	istream &cin = ifstream("input.txt");
#endif
	cout << dec;
	int n;
	cin >> n;
	rep(i, n) {
		vector<int> v1(100), v2(100);
		string s1, s2;
		cin >> s1 >> s2;
		rep(j, s1.size()) v1[j] = s1[s1.size() - j - 1] - '0';
		rep(j, s2.size()) v2[j] = s2[s2.size() - j - 1] - '0';
		
		rep(j, 99) {
			v1[j] += v2[j];
			if (v1[j] >= 10) {
				v1[j] -= 10;
				v2[j + 1]++;
			}
		}
		int digit = 0;
		for (int j = 99; j >= 0; j--) {
			if (digit == 0 && v1[j]) {
				digit = j;
				break;
			}
		}
		if (digit >= 79) cout << "overflow" << endl;
		else {
			for (int j = digit; j >= 0; j--) cout << v1[j];
			cout << endl;
		}
	}

}




int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);


	solve();
	//system("PAUSE");
	return 0;
}

C++: #include<stdio.h>
#include<iostream>
#include<list>
#include<map>
#include<vector>
#include<algorithm>
#include<string.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) range(i,0,b)
#define debug(x) cout << x << endl;
using namespace std;

int main(){
    char in1[81], in2[81];
    int n;
    cin >> n;
    rep(k,n){
        cin >> in1 >> in2;
        if(strlen(in1) > 80 || strlen(in2) > 80){
            cout << "overflow" << endl;
            break;
        }
        int ans[81] = {0};
        int j = 0;
        for(int i = strlen(in1); i > 0; i--){
            ans[81 - i]+= in1[j] - '0';
            j++;
        }
        j = 0;
        for(int i = strlen(in2); i > 0; i--){
            ans[81 - i]+= in2[j] - '0';
            j++;
        }
        for(int i = 80; i >= 0; i--){
            if(ans[i] >= 10){
                ans[i]-= 10;
                ans[i - 1]++;
            }
        }
        if(ans[0] != 0){
            cout << "overflow" << endl;
            break;
        }
        int len = 80 - max(strlen(in1), strlen(in2)) + 1;
        if(ans[len - 1] != 0)
            cout << ans[len - 1];
        range(i, len, 81){
                cout << ans[i];
        }cout << endl;
    }
}

C++: #include<iostream>
#include<stdio.h>
#include<string.h>

int n;
char a[256], b[256];
int temp[100], temp2[100];

int main()
{
        std::cin >> n;
	
	while( n-- ){
		memset( temp, 0, sizeof( temp ) );
		memset( temp2, 0, sizeof( temp2 ) );
		
		std::cin >> a >> b;
		
		int maxlen = std::max( strlen( a ), strlen( b ) );
		
		if( maxlen > 80 ){
			std::cout << "overflow" << std::endl;
		 	continue;
		}
		
		for( int i = 0; i < strlen( a ); i++ ){
			temp[strlen( a ) - i - 1] = a[i] - '0';
		}
		
		for( int i = 0; i < strlen( b ); i++ ){
			temp2[strlen( b ) - i - 1] = b[i] - '0';
		}
		
		for( int i = 0; i < maxlen; i++ ){
			temp[i+1] += ( temp[i] + temp2[i] ) / 10;
			temp[i] = ( temp[i] + temp2[i] ) % 10;
		}
		
		if( temp[maxlen] ){
		 	if( maxlen + 1 > 80 ){
				std::cout << "overflow" << std::endl;
				continue;
			}
			
			std::cout << temp[maxlen];
		}
		
		for( int i = maxlen - 1; i >= 0; i-- ){
		 	std::cout << temp[i];
		}
		std::cout << std::endl;
	}

 	return 0;
}