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++: #include <iostream>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm>	// require sort next_permutation count __gcd reverse etc.
#include <cstdlib>	// require abs exit atof atoi 
#include <cstdio>		// require scanf printf
#include <functional>
#include <numeric>	// require accumulate
#include <cmath>		// require fabs
#include <climits>
#include <limits>
#include <cfloat>
#include <iomanip>	// require setw
#include <sstream>	// require stringstream 
#include <cstring>	// require memset
#include <cctype>		// require tolower, toupper
#include <fstream>	// require freopen
#include <ctime>		// require srand
#define rep(i,n) for(int i=0;i<(n);i++)
#define ALL(A) A.begin(), A.end()

using namespace std;

typedef long long ll;
typedef pair<int, int> P;

string longlong_add (string str1, string str2 )
{
	string res = "";
	
	reverse (str1.begin(), str1.end() );
	reverse (str2.begin(), str2.end() );
	int len1 = str1.length();
	int len2 = str2.length();

	while (len1 != len2 ){
		if (len1 < len2 ){
			str1 += '0';
			len1 = str1.length();
		}else if (len1 > len2 ){
			str2 += '0';
			len2 = str2.length();
		} // end if
	} // end while

	bool carry = false;
	for (int i = 0; i < len1; i++ ){
		int num1 = str1[i] - '0';
		int num2 = str2[i] - '0';
		int sum = num1 + num2;

		sum += (carry ? 1 : 0 );

		if (sum < 10 ){
			res += sum + '0';
			if (carry){
				carry = false;
			} // end if
		}else{
			sum %= 10;
			res += sum + '0';
			carry = true;
		} // end if
	} // end for

	if (carry ){
		res += '1';
	} // end if

	reverse (res.begin(), res.end());

	return res;
}

int main()
{
//	cut here before submit 
//	freopen ("testcase.NB", "r", stdin );
	int n;
	scanf ("%d", &n );
	rep (i, n ){
		string a1, a2;
		cin >> a1 >> a2;
		bool ok = true;
		if (a1.length() > 80 && a2.length() > 80 ){
			ok = false;
		} // end if
		string add = longlong_add (a1, a2 );
		if (add.length() > 80 ){
			ok = false;
		} // end if
		if (ok ){
			cout << add << endl;		
		}else{
			printf ("overflow\n" );
		} // end if
	} // end rep

	return 0;
}

C++: #include<iostream>
#include<stdio.h>
#include <algorithm>
#include<string.h>
#include <utility>
using namespace std;
using namespace std;
int main(){
	int m;
	string in,in2;
	int a[90],b[90],ans[90];
	int f;
	int alen,blen,mlen;
	cin>>m;
	while(m--){
		for(int i=0;i<90;i++){
			a[i]=b[i]=ans[i]=0;
		}
		cin>>in;
		cin>>in2;
		alen=in.size();
		blen=in2.size();
		for(int i=0;i<alen;i++){
			a[alen-1-i]=in[i]-'0';
		}
		for(int i=0;i<blen;i++){
			b[blen-1-i]=in[i]-'0';
		}
		mlen=max(alen,blen);
		if(mlen>80){
			cout<<"overflow"<<endl;
			continue;
		}
		f=0;
		for(int i=0;i<mlen+1;i++){
			ans[i]=(a[i]+b[i]+f)%10;
			f=(a[i]+b[i]+f)/10;
		}
		if(ans[mlen]!=0){
			//if(m_len>79){
				//cout<<"overflow"<<endl;
				//continue;
			//}
			//cout<<ans[m_len];
		}
		
		for(int i=0;i<mlen;i++){
			cout<<ans[mlen-1-i];
		}cout<<endl;
		
		
	}
	return 0;
}

C++: import java.io.*;
import java.util.*;
import java.math.*;

class Main{	
		public static void main(String args[]) throws IOException{
			ArrayList<String> inp = new ArrayList<String>();
			
			Scanner scan = new Scanner(System.in);
			String str1 = scan.next();

			BigInteger big_inp;
			String str_c;

			int n = Integer.valueOf(str1).intValue();
			
			while(scan.hasNext()){
					str1 = scan.next();
					if(str1.length() > 80){System.out.println("overflow");}
					inp.add(str1);
			}

			BigInteger big_sum;
			for(int i=0;i<inp.size()/n;i++){
				big_sum = new BigInteger("0");
				for(int j=0;j<n;j++){
					big_inp = new BigInteger(inp.get(i*n+j));
					big_sum = big_sum.add(big_inp);
				}
				str_c = big_sum.toString();
				
				if(str_c.length() > 80)System.out.println("overflow");
				else System.out.println(big_sum);
			}
	}
}

C++: #include <stdio.h>

#define N 80

// Longint <- String
int init(int a[], char s[]);
// a <- b + c
int add(int a[], int b[], int c[]);
// print Longint
void print(int a[]);

int main(void){
	int n;
	int a[N], b[N], sum[N];
	char s[101], t[101];
	
	scanf("%d", &n);
	for (int i=0; i<n; i++){
		scanf("%s", s);
		scanf("%s", t);
		if (init(a, s)==-1 || init(b, t)==-1){
			puts("overflow");
			continue;
		}
		if (add(sum, a, b)==-1){
			puts("overflow");
		} else {
			print(sum);
		}
	}
	return 0;
}

// Longint <- String
int init(int a[], char s[]){
	int len=0;
	
	for (int i=0; i<N; i++) a[i] = 0;
	for (char *p=s; *p!='\0'; p++) len++;
	if (len>=N) return -1;
	for (int i=0; s[i]!='\0'; i++){
		a[N-len+i] = s[i] - '0';
	}
	return 0;
}
// a <- b + c
int add(int a[], int b[], int c[]){
	int cry=0;
	for (int i=N-1; i>=0; i--){
		a[i] = b[i]+c[i]+cry;
		cry = a[i]/10;
		a[i] %= 10;
	}
	return cry ? -1 : 0;
}

// print Longint
void print(int a[]){
	int i;
	for (i=0; i<N && a[i]==0; i++)
	;
	if (i==N){
		puts("0");
		return;
	} else {
		for (; i<N; i++){
			printf("%d", a[i]);
		}
		puts("");
	}
}

C++: #include<algorithm>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

using namespace std;
int main(){
	int n,l,m,c;
	char a[90],b[90],s[90];
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		for(int j=0;j<90;j++)s[j]=0;
		scanf("%s%s",a,b);
		l = strlen(a);
		m = strlen(b);
		reverse(a,a+l);
		reverse(b,b+m);
		c=0;
		for(int j=0;j<max(l,m);j++){
			int o=c;
			if(j<l)o += a[j]-'0';
			if(j<m)o += b[j]-'0';
			c = o>9;
			s[j] = o%10 + '0';
		}
		l=max(l,m);
		if(c>0)s[l++]='1';
		reverse(s,s+l);
		if(l>80)puts("overflow");
		else puts(s);
	}
	return 0;
}

C++: #include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int main (void) {
    int N;
    cin >> N;
    while (N--) {
        string s1, s2;
        cin >> s1;
        cin >> s2;
        vector<int> n1, n2, res;
        for (int i = s1.size(); i--;) {
            n1.push_back((int)(s1[i] - '0'));
        }
        for (int i = s2.size(); i--;) {
            n2.push_back((int)(s2[i] - '0'));
        }
        if (n1.size() < n2.size()) {
            for (int i = n1.size(); i < n2.size(); i++) {
                n1.push_back(0);
            }
        } else if (n2.size() < n1.size()) {
            for (int i = n2.size(); i < n1.size(); i++) {
                n2.push_back(0);
            }
        }
        int s, c = 0;
        for (int i = 0; i < n1.size(); i++) {
            s = n1[i] + n2[i] + c;
            res.push_back(s % 10);
            c = s / 10;
        }
        if (c != 0) {
            res.push_back(c);
        }
        int size = res.size();
        while (size > 0 && res[size - 1] == 0) {
            size--;
        }
        if (size >= 80) {
            cout << "overflow" << endl;
        } else {
            int i = size;
            while (i--) {
                cout << res[i];
            }
            cout << endl;
        }
    }
    return 0;
}