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;
	char in[2][100];
	char ans[100];
	int ie[2];
	int ien[2];
	bool max10;
	int Min;
	bool NMin;
	scanf("%d",&m);
	for(;m--;){
		
		for(int i=0;i<2;i++){
			scanf(" %s",&in[i]);
		}
		ie[0]=strlen(in[0])-1;
		ie[1]=strlen(in[1])-1;
		Min=max(ie[0],ie[1]);
		if((Min>79)||((Min>78)&&(ie[0]==ie[1])&&((int(in[0][0])+int(in[1][0]))>9))){
			cout<<"overflow"<<endl;
		}else{	
			if(ie[0]>ie[1]){
				NMin=0;
			}else{
				NMin=1;
			}
			ien[0]=ie[0];
			ien[1]=ie[1];
			for(;min(ien[0],ien[1])+1;ien[0]--,ien[1]--){
				in[NMin][ien[NMin]]=in[0][ien[0]]+in[1][ien[1]]-'0';
				if(in[NMin][ien[NMin]]>9+'0'){
					in[NMin][ien[NMin]]-=10;
					in[NMin][ien[NMin]-1]  +=1;
				}
			}
			max10=0;
			for(;ien[NMin]>-1;ien[NMin]--){
				if(in[NMin][ien[NMin]]>9+'0'){
					in[NMin][ien[NMin]]-=10;
					in[NMin][ien[NMin]-1]+=1;
					max10=1;
				}else{
					max10=0;
				}
			}
			if(max10) cout<<"1";
			cout<<in[NMin]<<endl;
		}
	}
	return 0;
}

C++: #include<iostream>
#include<string>
using namespace std;
void addplace(unsigned int *a, unsigned int *last, long long num){
if( a == last ) return;
int carry = ((long long)*a * 10L + num) / 1000000000L;
addplace(a+1, last, carry);
*a = ((long long)*a * 10L + num) % 1000000000L;
}
int trace(unsigned int *a, unsigned int *last){
if( a == last ) return 0;
if( !trace(a+1, last) ){
if( *a > 0 ){
cout << *a;
return 1;
}
}else{
char b[11]={};
sprintf(b,"%d",*a+1000000000);
cout<<b+1;
return 1;
}
return 0;
}
void add(unsigned int *a, unsigned int *alast, unsigned int *b, int num=0){
if( a == alast ) return;
int carry = (*a + *b + num) / 1000000000L;
add(a+1, alast, b+1, carry);
*a = (*a + *b + num) % 1000000000L;
}
int main(){
int n;
cin>>n;
string a,b;
getline(cin, a);
for(;n--;){
getline(cin, a);
getline(cin, b);
unsigned int _a[9]={},_b[9]={};
for(string::iterator it=a.begin();
it!=a.end(); it++){
addplace(_a, _a+9, *it-'0');
}
for(string::iterator it=b.begin();
it!=b.end(); it++){
addplace(_b, _b+9, *it-'0');
}
add(_a, _a+9, _b);
if( _a[8] >= 100000000 ){
cout<<"overflow\n";
}else{
trace(_a, _a+9);
cout<<'\n';
}
}
}

C++: #include<cstdio>
#include<cstring>
#include<cstdlib>

int main(void)
{
	char num1[1000], num2[1000];
	int n, num1_k, num2_k, rec, nnum1, nnum2, k_up, bnum1, bnum2;
	int f1, f2;
	scanf("%d", &n);
	fflush(stdin);
	for(f1 = 0; f1 < n; f1++)
	{
		//初期化
		k_up = 0;
		//入力
		scanf("%s", num1);
		scanf("%s", num2);
		//それぞれの桁数を求める
		num1_k = strlen(num1);
		num2_k = strlen(num2);
		bnum1 = num1_k - 1;
		bnum2 = num2_k - 1;
		//桁数で低いほうの桁数分だけ回す
		rec = (num1_k > num2_k) ? num2_k : num1_k;
		for(f2 = rec - 1; f2 >= 0; f2--)
		{
			//それぞれ現在桁の数を割り出す
			nnum1 = num1[bnum1] - '0';
			nnum2 = num2[bnum2] - '0';
			//桁数の大きいほうへ入れる
			if(num1_k > num2_k)
			{
				num1[bnum1] = ((nnum1 + nnum2 + k_up) % 10) + '0';
			}
			else
			{
				num2[bnum2] = ((nnum1 + nnum2 + k_up) % 10) + '0';
			}
			//桁上がりを求める
			k_up = (nnum1 + nnum2) / 10;
			bnum1--;
			bnum2--;
		}
		//残りの部分を求める
		rec = (bnum1 > bnum2) ? bnum1 : bnum2;
		for(f2 = rec; f2 >= 0; f2--)
		{	
			//桁数の大きいほうへ入れる
			if(num1_k > num2_k)
			{
				nnum1 = num1[f2] - '0';
				num1[f2] = ((k_up + nnum1) % 10) + '0';
				k_up = (k_up + nnum1) / 10;
			}
			else
			{
				nnum2 = num2[f2] - '0';
				num2[f2] = ((k_up + nnum2) % 10) + '0';
				k_up = (k_up + nnum2) / 10;
			}			
		}
		if(num1_k > 80 || num2_k > 80)
		{
			printf("overflow\n");
		}
		else
		{
			if(k_up == 1)
			{
				if(num1_k + 1 > 80 || num2_k + 1 > 80)
				{
					printf("overflow\n");
				}
				else
				{
					printf("%d", k_up);
				}
			}
			if(num1_k > num2_k)
			{
				printf("%s\n", num1);
			}
			else
			{
				printf("%s\n", num2);
			}
		}
	}
	return 0;
}

C++: //RE
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<deque>
#include<map>
#include<set>
#include<string>
#include<sstream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cctype>
#include<climits>
using namespace std;
#define REP(i, j) for(int i = 0; i < j; i++)
#define FOR(i, j, k) for(int i = j; i < k; i++)
#define P pair<int, int>
const int INF = INT_MAX / 2;
const int N = 100;

vector<int> makeDx(string str){
    reverse(str.begin(), str.end());
    vector<int> ret(N, 0);
    REP(i, str.size()) ret[i] = str[i] - '0';
    return ret;
}

bool isOver80(vector<int> dx){
    FOR(i, 80, dx.size()) if(dx[i] != 0) return true;
    return false;
}

int main(){
    int n; cin >>n;
    REP(z, n){
        string str[2]; cin >>str[0] >>str[1];
        if(str[0].size() > 80 || str[1].size() > 80){
            cout <<"NA" <<endl;
            continue;
        }

        vector<int> dx[2] = {makeDx(str[0]), makeDx(str[1])};
        vector<int> ans(N, 0);

        REP(i, max(dx[0].size(), dx[1].size())){
            ans[i] += (dx[0][i] + dx[1][i]);
            ans[i + 1] += (ans[i] / 10);
            ans[i] = ans[i] % 10;
        }

        if(isOver80(ans)){
            cout <<"NA" <<endl;
            continue;
        }

        reverse(ans.begin(), ans.end());
        int s = 0;
        while(ans[s] == 0 && s < N - 1) s++;
        FOR(i, s, ans.size()) cout <<ans[i];
        cout <<endl;
    }
    return 0;
}

C++: #include<iostream>
#include<string>
#include<vector>
int main(int, char**)
{
	int number = 0;
	std::cin >> number;

	std::string buff1;
	std::string buff2;
	for (int count = 0; number > count; ++count)
	{
		std::cin >> buff1 >> buff2;

		std::vector<std::string> sum;
		sum.reserve(10);
		int carry = 0;
		for (int offset = 0; buff1.length() > offset || buff2.length() > offset; offset += 8)
		{
			auto cutoff = [](const std::string& buff, const int offset)->int
			{
				if (buff.length() <= offset)
				{
					return 0;
				}
				if (buff.length() <= offset + 8)
				{
					return std::stoi(buff.substr(0, buff.length() - offset));
				}
				return std::stoi(buff.substr(buff.length() - offset - 8, 8));
			};
			int num1 = cutoff(buff1, offset);
			int num2 = cutoff(buff2, offset);
			std::string sum_buff = std::to_string(num1 + num2 + carry);
			
			if (8 < sum_buff.length())
			{
				carry = std::stoi(sum_buff.substr(0, 1));
				sum.emplace_back(sum_buff.substr(1));
			}
			else
			{
				carry = 0;
				sum.emplace_back(sum_buff);
			}
		}
		if (10 < sum.size() || (sum.size() == 10 && sum[0].length() == 8 && 0 != carry))
		{
			std::cout << "overflow";
		}
		else
		{
			if (0 != carry)
			{
				std::cout << std::to_string(carry);
			}
			for (int index = static_cast<int>(sum.size()) - 1; 0 <= index; --index)
			{
				if (index != static_cast<int>(sum.size()) - 1 && "0" == sum[index])
				{
					std::cout << "00000000";
				}
				else
				{
					std::cout << sum[index];
				}
			}
		}
		std::cout << std::endl;
	}
}