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<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 a_len,b_len,m_len;
	cin>>m;
	while(m--){
		for(int i=0;i<90;i++){
			a[i]=b[i]=ans[i]=0;
		}
		cin>>in;
		cin>>in2;
		a_len=in.size();
		b_len=in2.size();
		for(int i=0;i<a_len;i++){
			a[a_len-1-i]=in[i]-'0';
		}
		for(int i=0;i<b_len;i++){
			b[b_len-1-i]=in[i]-'0';
		}
		m_len=max(a_len,b_len);
		if(m_len>80){
			cout<<"overflow"<<endl;
			continue;
		}
		f=0;
		for(int i=0;i<m_len+1;i++){
			ans[i]=(a[i]+b[i]+f)%10;
			f=(a[i]+b[i]+f)/10;
		}
		if(ans[m_len]!=0){
			if(m_len>79){
				cout<<"overflow"<<endl;
				continue;
			}
			//cout<<ans[m_len];
		}/*
		for(int i=0;i<m_len;i++){
			cout<<ans[m_len-1-i];
		}cout<<endl;
		
		*/
	}
	return 0;
}

C++: #include <iostream>
#include <algorithm>
#include <cstdio>
#include <string>
#include <vector>
using namespace std;

int main(void) {
    
    
    int num; cin >> num;
    int k = 0;
    for(int r = 0; r < num; r++) {
        vector<int> vec;
        string a, b; cin >> a >> b;
        if(a.size() > 80 || b.size() > 80) {
            cout << "overflow" << endl; continue;
        }
        
        for(int r = 0; r < 82; r++) {
            if(r >= a.size() && r >= b.size() && k != 1) break;
            int c = k;
            k = 0;
            if(r < a.size()) c += a[a.size() - 1 - r] - '0';
            if(r < b.size()) c += b[b.size() - 1 - r] - '0';
            if(c > 9) k = 1;
            vec.push_back(c % 10);
        }
        if(vec.size() > 80) {
            cout << "overflow" << endl;
            continue;
        }
        for(int r = (int)vec.size() - 1; r >= 0; r--) cout << vec[r];
        cout << endl;
    }
    return(0);
}

C++: #include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <string>
#define rep(x,to) for(x=0;x<to;x++)
#define rep2(x,from,to) for(x=from;x<to;x++)

using namespace std;
int main(void){

int nn,dd,i,j;
char qq[82];
	cin >> nn;
	vector<string> ww1(nn);
	vector<string> ww2(nn);
	rep(i,nn) cin >> ww1[i] >>ww2[i];
	rep(i,nn){
		fill(qq,qq+81,'#');
		int sz=ww1[i].size();
		rep(j,sz) qq[81-j] = ww1[i][sz-1-j];
		sz=ww2[i].size();
		int kup =0;
		rep(j,sz){
			if(qq[81-j] == '#') qq[81-j] = '0';
			kup = ( qq[81-j] - '0') + (ww2[i][sz-1-j] - '0');
			qq[81-j] = kup % 10 + '0';
			if(kup>9) {
				if (qq[81-j-1] == '#') qq[81-j-1] = '0';
				qq[81-j-1] = (( qq[81-j-1] - '0') + 1) + '0';
						
			}
		}
	if(qq[0] !='#' || qq[1] != '#') cout << "overflow" << endl;
	else rep(j,82) if(qq[j] != '#') cout << qq[j];
	cout << endl;
	}	
//	rep(i,82) cout << qq[i] ;
	return 0;
}

C++: #include <iostream>
#include "bits/stdc++.h"

#include <vector>
#include <string>
using namespace std;

int main(){
	string a, b;
	vector<int> ans;
	int n, num, ai, bi, c=0;
	bool flag;

	cin >> n;

	for(int i=0 ; i<n ; i++){
		cin >> a >> b;
		flag = false;

		for(int j=0 ; j<100 ; j++){
			num = 0;
			ai = a.size()-j-1;
			bi = b.size()-j-1;
			if( ai<0 && bi<0 && c==0) break;

			if(ai>=0)num += a[ ai ] - 48;
			if(bi>=0)num += b[ bi ] - 48;
			ans.push_back( (num+c)%10 );
			if(num+c >= 10) c = 1;
			else c = 0;
		}
		if(ans.size()>80){
			printf("overflow");
		}else{
			for(int j=ans.size()-1 ; j>=0 ; --j){
				printf("%d", ans[j]);
			}
		}
		printf("\n");
		ans.clear();
	}
	return 0;
}

C++: #include <iostream>
#include <vector>
#include <cstdio>
#define N 10000
using namespace std;

char s[N];
vector<int> a,b;
int n, an,bn;

void pr( vector<int> a ){
  unsigned int i=0, len;
  while( a[i]==0 ) i++;

  len = a.size()-i;
  //  cout << "length : "<< len << endl;
  if( len>80 ){
    cout << "overflow";
  }else{
    for( ;i<a.size();i++ )
      cout << a[i];
  }
  cout << endl;
}

int main(){
  cin >> n;
  fgets( s,N,stdin );
  for( int loop=0;loop<n;loop++ ){
    a.clear();
    fgets( s,N,stdin );
    
    for( int i=0; s[i]!='\n' ;i++ )
      a.push_back( s[i]-'0' );
    b.clear();
    fgets( s,N,stdin );
    for( int i=0;s[i]!='\n';i++ )
      b.push_back( s[i]-'0' );
    an=a.size(); bn=b.size();

    while( an>bn ){
      b.insert( b.begin(),1, 0 ); bn++;
    }
    while( an<bn ){
      a.insert( a.begin(),1, 0 ); an++;
    }
    //    pr(a);
    //    pr(b);
    a.insert( a.begin(),1,0 );
    b.insert( b.begin(),1,0 );
    for( int i=an;i>=0;i-- ){
      a[i]+=b[i];
      if( a[i]>=10 ){
	a[i]-=10; a[i-1]++;
      }
    }
    pr( a );
  }
  return 0;
}

C++: #include <iostream>
#include <string>
#include <utility>
#include <algorithm>
#include <queue>
#include <map>
#include <fstream>
#include <array>
#include <utility>
#include <functional>
#include <stack>

using namespace std;
typedef long long Int;
#define REP(i , x) for(Int i = 0 ; i < x ; ++i)

typedef pair<int, int> P;


int main()
{
	int n;
	cin >> n;
	REP(i, n){
		string a, b;
		int a_a[100] = { 0 };
		int b_a[100] = { 0 };
		int c_a[100] = { 0 };
		cin >> a >> b;

		vector<char> a_b(a.rbegin(), a.rend());
		vector<char> b_b(b.rbegin(), b.rend());

		if (a_b.size() > 80 || b_b.size() > 80){
			cout << "overflow" << endl;
			continue;
		}

		int carry(0);
		vector<int> ans;

		if (a_b.size() > b_b.size()){
			b_b.resize(a_b.size(), '0');
		}
		else{
			a_b.resize(b_b.size(), '0');
		}

		REP(i, a_b.size()){
			int temp = a_b[i] - '0' + b_b[i] - '0' + carry;
			carry = temp / 10;
			ans.push_back(temp % 10);
		}

		if (carry)
			ans.push_back(carry);

		if (ans.size() > 80){
			cout << "overflow" << endl;
			continue;
		}

		for (unsigned i = 0; i < ans.size(); i++) {
			cout << ans[ans.size() - 1 - i];
		}

		cout << endl;
	}

	return 0;
}