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 <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <queue>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <complex>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <fstream>
#include <stdio.h>

using namespace std;

//conversion
//------------------------------------------
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}

//typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<double> VEC;
typedef vector<VEC> MAT;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<int, PII> TIII;
typedef long long LL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
//container util

//------------------------------------------
#define ALL(a)  (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define MT(a,b,c) MP(a, MP(b, c))
#define T1 first
#define T2 second.first
#define T3 second.second.first
#define T4 second.second.second

//repetition
//------------------------------------------
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)
#define EPS 1.0e-9

inline int getnum(string s, int idx){
	if(idx >= s.size())return 0;
	else return s[idx]-'0';
}

string add(string s, string t){
	reverse(ALL(s));
	reverse(ALL(t));
	int n=max(s.length(), t.length());
	string r;
	int ku=0;
	REP(i,n){
		int tmp = getnum(s,i)+getnum(t,i)+ku;
		r.PB(tmp%10+'0');
		ku=tmp/10;
	}
	if(ku)r.PB('0'+ku);
	reverse(ALL(r));
	return r;
}

int main(){
	int t;
	cin >> t;
	REP(i,t){
		string s1,s2;
		cin>>s1>>s2;
		cout << add(s1,s2) << endl;
	}
	return 0;
}

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

//const static double	de_PI	= 3.14159265358979323846;
//const static int	de_MOD	= 1000000007;
//const static int	de_MAX	= 999999999;
//const static int	de_MIN = -999999999;

inline std::string Add_MultiplePrecision(const std::string A, const std::string B) {

	int a[200] = {0};
	int b[200] = {0};
	int c[300] = {0};

	for (unsigned int i = 0; i < A.length(); i++) {
		a[i] = A[A.length() - 1 - i] - '0';
	}
	for (unsigned int i = 0; i < B.length(); i++) {
		b[i] = B[B.length() - 1 - i] - '0';
	}

	int carry = 0;
	for (unsigned int i = 0; i < std::max(A.length(), B.length()); i++) {
		c[i] = (a[i] + b[i] + carry) % 10;
		c[i + 1] = carry = (a[i] + b[i] + carry) / 10;
	}

	int st = 299;
	while (c[st] == 0) {
		st--;
	}

	std::string ans;
	for (int i = st; i >= 0; i--) {
		ans += std::to_string(c[i]);
	}

	if (ans == "") {
		ans = "0";
	}

	return(ans);
}

int main(void) {

	//std::ifstream in("123.txt");	std::cin.rdbuf(in.rdbuf());

	int n = 0;
	std::cin >> n;
	std::vector<std::string> ans;

	std::string temp1, temp2, temp3;
	while (std::cin >> temp1) {
		std::cin >> temp2;
		temp3 = Add_MultiplePrecision(temp1, temp2);
		if (temp3.length() >= 80) {
			ans.push_back("overflow");
		}
		else {
			ans.push_back(temp3);
		}
	}

	for (unsigned int i = 0; i < ans.size(); i++) {
		std::cout << ans[i] << std::endl;
	}
}

C++: #include<iostream>
#include<cstring>
using namespace std;
int main(){
	int n;
	cin >>n;
	for(int i=0; i<n; i++){
		char num[2][900];
		int ans[900],up=0,t,l;
		cin >>num[0]>>num[1];
		int a = strlen(num[0]), b = strlen(num[1]), max = (b>a)? b:a, min = (b>a)? a:b;
		for(l=0; l<max; l++){
			if(l<min){t = (int)num[0][a-l-1]+(int)num[1][b-l-1]-48*2+up;}
			else if(a<b){t = (int)num[1][b-l-1]-48+up;}
			else{t = (int)num[0][a-l-1]-48+up;}
			if(t>9){t-=10;up = 1;}
			else{up = 0;}
			ans[l] = t;
		}
		if(up == 1){ans[max] = 1;l++;}
		if(l<=80)for(int m=l-1; m>=0; m--){cout <<ans[m];}
		else{cout<<"overflow";}
		cout <<endl;
	}
	return 0;
}

C++: 






#include<iostream>
#include<algorithm>
#include<string>


#define MAX 1000


using namespace std;


int main()
{
	int n = 0;
	string in[2];
	char out[MAX] = {NULL};

	cin >> n;

	for (int i = 0; i < n; i++){
		cin >> in[0] >> in[1];

		for (int i = 0; i < MAX; i++){
			out[i] = '\0';
		}

		int count = in[0].size() - 1;

		for (int i = 0; i < in[0].size(); i++){
			out[count--] += in[0][i];
		}

		count = in[0].size();
		int count2 = in[1].size() - 1;

		count = max(count , count2) - 1;

		for (int i = 0; i < in[1].size(); i++){
			if (out[i] != '\0'){
				out[i] -= '0';
			}
			out[i] += in[1][count2--];
			count--;
		}
		
		int i = 0;
		for (i = 0; out[i] != '\0'; i++){
			;
		}

		bool flag = false;


		for (int j = 0; j < i; j++){
			if (out[j] > '9'){
				out[j] -= 10;
				out[j + 1] += 1;
			}
		}

		if (out[i] > '\0' && out[i] < '0'){
			out[i] += '0';
		}
		
		for (i = 0; i < out[i] != '\0'; i++){
			;
		}

		for (int j = 0; j < i / 2; j++){
			char tmp = out[j];
			out[j] = out[i - j - 1];
			out[i - j - 1] = tmp;
		}

		for (i = 0; out[i]; i++){
			;
		}

		if (i >= 79 || (flag == true && i >= 79)){
			cout << "overflow" << endl;
		}else{
			cout << out << endl;
		}
	}

	return 0;
}

C++: #include <cstdio>
#include <cstring>
#define MAX_NUM 32767

using namespace std;

void array_add(int *a,int *b){
	int i;
	for(i = MAX_NUM - 1;i > 0;i--){
		a[i] = a[i] + b[i];
		a[i - 1] = a[i - 1] + a[i] / 10;
		a[i] %= 10;
	}
}

int main(void){
	int n, i, j, len1,len2, val1[MAX_NUM], val2[MAX_NUM];
	char c;
	scanf("%d%*c",&n);
	for(i = 0;i < n;i++){
		for(j = 0;(c = getchar()) != '\n';j++){
			val1[j] = c - '0';
		}
		len1 = j;
		for(j = 0;(c = getchar()) != '\n';j++){
			val2[j] = c - '0';
		}
		len2 = j;
		for(j = MAX_NUM - 1;j > MAX_NUM - 1 - len1;j--){
			val1[j] = val1[len1 - 1 + (j - (MAX_NUM - 1))];
		}
		for(;j >= 0;j--){
			val1[j] = 0;
		}
		val1[MAX_NUM] = 0;
		for(j = MAX_NUM - 1;j > MAX_NUM - 1 - len2;j--){
			val2[j] = val2[len2 - 1 + (j - (MAX_NUM - 1))];
		}
		for(;j >= 0;j--){
			val2[j] = 0;
		}
		array_add(val1,val2);
		for(j = 0;val1[j] == 0 && j < MAX_NUM;j++);
		if(j <= MAX_NUM - 81)
			printf("overflow");
		else if(j == MAX_NUM)
			printf("0");
		else{
		for(;j < MAX_NUM;j++){
			printf("%d",val1[j]);
		}
		}
		printf("\n");
	}
	return 0;
}