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")
		}
	}
}

Python: # 12,432 -> 012,432
def align_digits(a, b):
    la, lb = len(a), len(b)
    if la < lb:
        a = a.zfill(lb)
    elif lb < la:
        b = b.zfill(la)
    return a, b


def add(a, b):
    a, b = align_digits(a, b)
    zipped = list(zip(a[::-1], b[::-1]))
    carry = 0
    result = []
    for i, z in enumerate(zipped):
        a, b = z
        s = int(a) + int(b) + carry
        carry = int(s / 10)
        if i == len(zipped) - 1:
            result.append(str(s))
        else:
            result.append(str(s % 10))
    ans = ''.join(result[::-1])
    if len(ans) > 80:
        return 'overflow'
    return ans


if __name__ == '__main__':
    n_input = int(input())
    inputs = []
    for i in range(n_input):
        inputs.append((input(), input()))
    for a, b in inputs:
        print(add(a, b))

Python: n = int(input())
for _ in range(n):
    a = int(input())+int(input())
    if a >= 10**80:
        print("overflow")
    else:
        print(a)

Python: import math

N = int(input())
for i in range(N):
    a = int(input())
    b = int(input())
    if a >= 10 ** 80 or b >= 10 ** 80 or a + b >= 10 ** 80:
        print("overflow")
    else:
        print(a + b)

Python: from collections import deque

"""
# Too slow
def add2(a, b):
    a, b = align_digit(a, b)
    zipped = zip(a[::-1], b[::-1])
    carry = 0
    result = []
    for a, b in zipped:
        s = int(a) + int(b) + carry
        carry = int(s / 10)
        result.append(str(s % 10))
    if result[-1] == '0':
        result[-1] = str(carry)
    print(''.join(result[::-1]))
"""


def align_digit(a, b):
    la, lb = len(a), len(b)
    if la < lb:
        a = a.zfill(lb)
    elif lb < la:
        b = b.zfill(la)
    return a, b


def split_to_ints(s, n=10):
    length = len(s)
    return reversed([int(s[i:i + n]) for i in range(0, length, n)])


def add(a, b, n=10):
    a, b = align_digit(a, b)
    ints_a = split_to_ints(a, n)
    ints_b = split_to_ints(b, n)
    carry = 0
    result = deque()

    zipped = list(zip(ints_a, ints_b))
    for i, (int_a, int_b) in enumerate(zipped):
        s = int_a + int_b + carry
        carry = int(s / (10 ** n))
        if i != len(zipped) - 1:
            result.append(str(s % (10 ** (n - 1))).zfill(n))
        else:
            result.append(str(s))
        i += 1

    ret = str(int(''.join(result)))
    if len(ret) > 80:
        return 'overflow'
    return ret


if __name__ == '__main__':
    n_input = int(input())
    for i in range(n_input):
        a, b = input(), input()
        print(add(a, b))

Python: n=int(input())
for _ in range(n):
    a=int(input())
    b=int(input())
    ab=a+b
    print(ab if ab<10**80 else "overflow")

Python: import math

n1 = input();
n2 = input();
sum = int(n1) + int(n2);

if int(math.log10(sum)) + 1 > 80 :
	print("overflow");
else :
	print(sum)

Python: n=int(input())
for n in range(n):
	a=int(input())
	b=int(input())
	c=a+b
	if a>=int(1e79) or b>=int(1e79) or c>=int(1e79):
		print("overflow")
	else:
		print(c)

Python: times=int(input())
for i in range(times):
    a=int(input())
    b=int(input())
    if int(a/1e80)!=0 or int(b/1e80)!=0 or int((a+b)/(1e80))!=0:
        print("overflow")
    else: print(a+b)

Python: import math

N = int(input())
for i in range(N):
    a = int(input())
    b = int(input())
    if (a != 0 and math.log10(a) > 79) or (b != 0 and math.log10(b) > 79) or (a + b != 0 and math.log10(a + b)) > 79:
        print("overflow")
    else:
        print(a + b)

Python: o=map(str,[sum([int(input()) for j in range(2)]) for i in range(int(input()))])
[print(i) if len(i)<=80 else print("overflow") for i in o]

Python: #標準入力
j = int(input())
for _ in range(j):
    a = int(input())
    b = int(input())
    
    #aとbの和を計算
    num = a + b
    
    #桁数を調べ81以上であればoverflowを出力する
    num1 = [c for c in str(num)]
    if len(num1) > 80:num = "overflow"
    else:pass
    print(num)

Python: n = int(input())
for _ in range(n):
    a, b = input(), input()
    m = abs(len(a) - len(b))
    if len(a) > len(b):
        a = '0' + a
        b = '0' * (m+1) + b
    else:
        a = '0' * m + a
        b = '0' + b
    a, b = a[::-1], b[::-1]
    
    budget = []
    flag = False
    for i in range(0, len(a), 10):
        t = int(a[i:i+10][::-1]) + int(b[i:i+10][::-1]) 
        if flag: t += 1
        t = str(t)

        if len(t) > 10:
            t = t[1:]
            flag = True
        elif i + 10 < len(a):
            t = '0' * abs(len(t) - 10) + t
            flag = False
        else:
            flag = False
        budget.append(t)
    
    budget = ''.join(budget[::-1])
    if len(budget) < 80:
        print(''.join(budget[::-1]))
    else:
        print('overflow')

Python: #! /usr/bin/python

num_inputs = int(raw_input())

limit = 100000000000000000000000000000000000000000000000000000000000000000000000000000000

count = 0
while count < num_inputs:
	num1 = int(raw_input())
	num2 = int(raw_input())

	if num1 >= limit or num2 >= limit:
		print('overflow')
	else:
		num = num1 + num2
		if num >= limit:
			print('overflow')
		else:
			print(num)

	count += 1

Python: import sys
import itertools

dataset_num = int(input())

class Overflow(Exception):
    pass

for _ in range(dataset_num):
    try:
        k1 = input()
        k2 = input()
        k1_val = [0] * 100
        k2_val = [0] * 100

        if len(k1) > 80 or len(k2) > 80:
            raise Overflow()
        
        for i, x in enumerate(reversed(k1)):
            k1_val[i] = int(x)

        for i, x in enumerate(reversed(k2)):
            k2_val[i] = int(x)
        
        res = [0] * 100 
        for i in range(0, 100):
            res[i] += k1_val[i] + k2_val[i]
            if res[i] >= 10:
                res[i+1] += 1
                res[i] -= 10
        sumstr = "".join([str(x) for x in itertools.dropwhile(lambda x: x == 0, reversed(res))])
        if len(sumstr) > 80:
            raise Overflow()

        print(sumstr)
    except Overflow:
        print("overflow")

Python: import math

n = int(input())
for i in range(n):
    for i in range(2):
        x = int(input())
        y = int(input())
        result = x + y
        print(result) if math.log10(result) + 1 < 80 else print("overflow")

Python: n = int(input())
for i in range(n):
    x = input()
    y = input()
    if len(x) > 80 or len(y) > 80:
        print("overflow")
        continue
    s = ""
    rx = x[::-1]
    ry = y[::-1]
    lx = len(x)
    ly = len(y)
    if lx > ly:
        ml = lx
    else:
        ml = ly
    c = 0
    for j in range(ml + 1):
        x1 = 0
        y1 = 0
        if j < lx:
            x1 = int(rx[j])
        if j < ly:
            y1 = int(ry[j])
        c1 = x1 + y1 + c
        s += str(c1 % 10)
        c = c1 // 10

    rs = s[::-1]
    result = ""
    for j in range(len(rs)):
        if rs[j] != "0":
            result = rs[j:]
            break

    if len(result) > 80:
        print("overflow")
    else:
        print(result)