Go: package main

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

var sc = bufio.NewScanner(os.Stdin)

func main() {
	sc.Scan()
	dataset, _ := strconv.Atoi(sc.Text())
	var firstdata *big.Int

	for i := 0; i < dataset*2; i++ {
		n := new(big.Int)
		sc.Scan()
		data, _ := n.SetString(sc.Text(), 10)

		if i%2 == 0 {
			firstdata = data
			continue
		}

		result := new(big.Int)
		if result := result.Add(data, firstdata); len(result.String()) > 80 {
			fmt.Println("overflow")
			continue
		} else {
			fmt.Println(result)
		}
	}
}

C++: #include <iostream>
#include <vector>
#include<string>
#include<sstream>
#define CAPACITY 9


namespace jisaku{//stoi?????¨?????????????????????????????????????????§??£?¨???????

	int stoi(std::string str){
		int ret;
		std::stringstream ss;
		ss << str;
		ss >> ret;
		return ret;
	}

     std::string to_string(int i){
		 std::string text;
		std::stringstream textline;
		textline<< i;
		textline >> text;
		return text;
	}

}




class OverDigit{

public:

	int num_a[CAPACITY];
	int num_b[CAPACITY];
	OverDigit(std::string str_a, std::string str_b);
	void ChangeDigit(std::string str, int num[]);
	void Add();
};

OverDigit::OverDigit(std::string str_a, std::string str_b){

	ChangeDigit(str_a, num_a);
	ChangeDigit(str_b, num_b);

}

void OverDigit::ChangeDigit(std::string str, int num[]){

	std::vector <int> num_str(CAPACITY, 0);
	int loc = CAPACITY, k = 8;
	int  str_rest,str_Max;

	str_rest = str.length() % CAPACITY;
	str_Max = str.length() / 9;

	for (int j = str.length() - CAPACITY; str_Max > 0; j = j - CAPACITY){
		num_str[k] = jisaku::stoi(str.substr(j, CAPACITY));
		loc = k;
		k--;
		str_Max--;

	}
	//?????????????????????????????????????????\??????

	if (str_rest != 0)num_str[loc - 1] = jisaku::stoi(str.substr(0, str_rest));

	for (int j = 0; j < CAPACITY; j++){
		num[j] = num_str[j];
	}
}
//80????????§????¶???????
void OverDigit::Add(){

	int num_ans[CAPACITY] = {};
	int fat, overflow = 0, count = 0;
	std::string text,t;


	for (int j = CAPACITY - 1; j >0; j--){
		if (num_a[j] + num_b[j] <= 999999999){
			num_ans[j] = num_a[j] + num_b[j];
		}
		else if (num_a[j] + num_b[j] > 999999999){
			fat = (num_a[j] + num_b[j]) - 1000000000;
			num_ans[j] = fat;
			num_a[j - 1]++;
		}

	}

	if (num_a[0] + num_b[0] > 99999999){
		overflow = 1;
	}
	else{
		num_ans[0] = num_a[0] + num_b[0];


	}

	if (overflow == 1){
		std::cout << "overflow" << std::endl;
	}
	else {
		for (int j = 0; j < CAPACITY; j++){
			if (num_ans[j] != 0){
				count++;
				t = jisaku::to_string(num_ans[j]);
				if (t.length() != 9){
					for (int l = 0; l < (9 - t.length()); l++){
						text += "0";
					}
				}
				text += t;


				std::cout << text<<std::endl;
			}
			else if (num_ans[j] == 0 && count >= 1){
					text+="000000000";
					std::cout << text<<std::endl;
			}

		}std::cout <<text<< std::endl;
	}

};


int main(){

	std::cout << jisaku::to_string(55510);

	//vector???????????¨??????80???????¨????
	int N;
	std::string str_a, str_b;

	std::cin >> N;
	std::cin.ignore();

	for (int i = 0; i < N; i++){
		getline(std::cin, str_a);
		getline(std::cin, str_b);
		if (str_a == "0" && str_b == "0"){std::cout << '0' << std::endl;
		}
		else if (str_a.length() >= 81 || str_b.length() >= 81){
		
			std::cout << "overflow" << std::endl;
		}
		else{

			OverDigit OverDigit_a(str_a, str_b);//???????????§??????
			OverDigit_a.Add();
		}
	}
	return 0;
}

C++: #include <iostream>
#include <iomanip>
#include <cassert>
#include <string>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long ll;

const ll BASE = 10000;
const int LogB = 4;
const int MAX_DIGIT = 100;

struct Bigint {
	ll digit[MAX_DIGIT];
	int size;
	Bigint (int sz = 1, ll a = 0) : size(sz) {
		memset(digit, 0, sizeof(digit));
		digit[0] = a;
	}
};

const Bigint ZERO(1,0), ONE(1, 1);

bool operator < (Bigint x, Bigint y) {
	if (x.size != y.size) return x.size < y.size;
	for (int i=x.size-1; i>=0; i--) if (x.digit[i] != y.digit[i]) return x.digit[i] < y.digit[i];
	return false;
}

bool operator > (Bigint x, Bigint y) { return y < x; }
bool operator <= (Bigint x, Bigint y) { return !(y < x); }
bool operator >= (Bigint x, Bigint y) { return !(x < y); }
bool operator != (Bigint x, Bigint y) { return x < y || y < x; }
bool operator == (Bigint x, Bigint y) { return !(x < y) && !(y < x); }

Bigint normal(Bigint x) {
	ll c = 0;
	for (int i=0; i<x.size; i++) {
		while (x.digit[i] < 0)
			x.digit[i+1] -= 1, x.digit[i] += BASE;
		ll a = x.digit[i] + c;
		x.digit[i] = a % BASE;
		c = a / BASE;
	}
	for (; c>0; c /= BASE) x.digit[x.size++] = c % BASE;
	while (x.size > 1 && x.digit[x.size-1] == 0) x.size--;
	return x;
}

Bigint convert(ll a) { return normal(Bigint(1, a)); }

Bigint convert(const string& s) {
	Bigint x;
	int i = s.size() % LogB;
	if (i > 0) i -= LogB;
	for (; i<(int)s.size(); i += LogB) {
		ll a = 0;
		for (int j=0; j<LogB; j++) a = 10 * a + (i+j >= 0 ? s[i+j] - '0' : 0);
		x.digit[x.size++] = a;
	}
	reverse(x.digit, x.digit+x.size);
	return normal(x);
}

ostream &operator << (ostream& os, Bigint x) {
	os << x.digit[x.size-1];
	for (int i=x.size-2; i>=0; i--) os << setw(LogB) << setfill('0') << x.digit[i];
	return os;
}

istream &operator >> (istream& is, Bigint &x) {
	string s; is >> s;
	x = convert(s);
	return is;
}

Bigint operator + (Bigint x, Bigint y) {
	if (x.size < y.size) x.size = y.size;
	for (int i=0; i<y.size; i++) x.digit[i] += y.digit[i];
	return normal(x);
}

int main() {
	int n;
	cin >> n;
	string s1, s2;
	
	for (int i=0; i<n; i++) {
		cin >> s1;
		cin >> s2;
		Bigint x = convert(s1), y = convert(s2);
		Bigint z = x + y;
		if (z.size > 80) cout << "overflow" << endl;
		else cout << z << endl;
	}
	
	return 0;
}

C++: #include <iostream>
#define N 10000
using namespace std;
void mpstr2num(int *num, char *str);
void mpadd(int* ret, int* a, int* b);
void mpnum2str(char* str, int* num);

void mpstr2num(int* num, char* str){
    char* ss;
    int* nn;
    while(*str == ' ' || *str == '\t') str++;
    while(*str == '0') str++;
    ss = str;
    while(*ss >= '0' && *ss <= '9') ss++;
    if(ss == str){
        *num = 0;
        return;
    }
    int x = 0;
    int k = 1;
    nn = num;
    do{
        x+=(*--ss - '0') * k;
        k *= 10;
        if(k == N || ss == str){
            *++nn = x;
            x = 0;
            k = 1;
        }
    }while(ss != str);

    *num = nn - num;
    return;
}

void mpadd(int* ret, int* a, int* b){
    int la = *a;
    int lb = *b;
    int lr = (la >= lb) ? la : lb;
    int* rr = ret;
    int x = 0;
    for(int i=1; i<= lr; i++){
        if(i <= la) x += *++a;
        if(i <= lb) x += *++b;
        if(x < N){
            *++rr = x;
            x = 0;
        }else{
            *++rr = x - N;
            x = 1;
        }
    }
    *++rr = x;
    *ret = lr + x;
    return;
}

void mpnum2str(char* str, int* num){
    if(*num == 0){
        *str++ = '0';
        *str = '\0';
        return;
    }
    char* ss = str - 1;
    int x;
    for(int i=*num; i>0; i--){
        x = *++num;
        for(int j=1; j<N; j*=10){
            *++ss = x%10 + '0';
            x /= 10;
        }
    }
    while(*ss == '0') ss--;

    *(ss+1) = '\0';
    while(str < ss){
        x = *str;
        *str++ = *ss;
        *ss-- = x;
    }

    return;
}

int main(){
    int n;
    cin >> n;
    for(int i=1; i<=n; i++){
        char a[100], b[100];
        int anum[25], bnum[25];
        int resultnum[50];
        char result[200];
        cin >> a >> b;
        mpstr2num(anum, a);
        mpstr2num(bnum, b);
        mpadd(resultnum, anum, bnum);
        mpnum2str(result, resultnum);
        cout << result << endl;
    }
    return 0;
}