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: for _ in range(int(input())):
    a=int(input())+int(input())
    print(a if a < 10**80 else 'overflow')

Python: n = int(input())
for i in range(n):
    a = int(input())
    b = int(input())
    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
    return str(int(''.join(result)))


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

Python: import math

def main() :
    n = int(input())
    for i in range(0, n) :
        a = int(input())
        b = int(input())
        if (math.log10(a + b) + 1 > 80) :
            print("overflow")
            continue
        print(a + b)

main()

Python: from __future__ import (absolute_import, division, print_function,
                        unicode_literals)
from sys import stdin

n = int(stdin.readline())
while n:
    result = long(stdin.readline()) + long(stdin.readline())
    if len(str(result)) >= 80:
        print('overflow')
    else:
        print(result)
    n -= 1

Python: #!/usr/bin/env python
#-*- coding:utf-8 -*-

import sys
import math

n = int(input())
result = 0

for i in range(n):
    result = 0
    x = int(input())
    y = int(input())

    result = x + y
    length = len(str(result))
    if length > 80:
        print("overflow")
    else:
        print(result)

Python: for _ in range(int(input())):
    a = int(input())
    b = int(input())
    s = a + b
    if s >= 1e80:
        print('overflow')
    else:
        print(s)

Python: def Add(numa, numb):
	longer = (numa if len(numa) >= len(numb) else numb)
	shorter = (numa if len(numa) < len(numb) else numb)
	carry = 0
	result = ''
	for s in range(-1, -len(shorter) - 1, -1):
		ans = int(longer[s]) + int(shorter[s]) + carry
		if ans >= 10:
			result = str(ans % 10) + result
			carry = 1
		else:
			result = str(ans) + result
			carry = 0
	for l in range(-len(shorter) - 1, -len(longer) - 1, -1):
		ans = int(longer[l]) + carry
		if ans >= 10:
			result = str(ans % 10) + result
			carry = 1
		else:
			result = str(ans) + result
			carry = 0
	return (result if carry == 0 else '1' + result)

N = eval(input())
for _ in range(N):
	a = input()
	b = input()
	print(Add(a, b))

Python: n = int(input())
for i in range(n):
    a = int(input())
    b = int(input())
    if (a + b) // (10 ** 80) > 0:
        print('overflow')
    else:
        print(a + b)

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

Python: def main():
    n = int(input())
    Upper = 10**80
    for i in range(n):                       
            a = int(input())
            b = int(input())
            if a+b >= Upper:
                print("overflow")
            else:
                print(a+b)
if __name__ =='__main__':
    main()

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)
    
    print(''.join(budget[::-1]))

Python: N = int(input())
import re
for _ in [0]*N:
    a = tuple(map(int, input().zfill(100)))
    b = tuple(map(int, input().zfill(100)))
    result = []
    prev = 0
    for i in range(1, 80):
        n = int(a[-i]) + int(b[-i]) + prev
        result.append(n%10)
        prev = n // 10
    if a[-81] + b[-81] + prev > 0:
        print("overflow")
    else:
        print(re.sub(r"^0+", "", "".join(map(str, result[::-1]))))

Python: def overflow(s):
    if len(s) > 80:
        print('overflow')
    else: 
        print(s)

def string_sum(la, lb):
    d = abs(len(la) - len(lb))
    if len(la) > len(lb):
        lb = "0" * d + lb
    else:
        la = "0" * d + la
    ls = []
    carry = 0
    for a, b in zip(la[::-1], lb[::-1]):
        s = int(a) + int(b) + carry
        ls.append(str(s % 10))
        carry = s // 10
    if carry == 1:
        ls.append('1')
    return ''.join(ls[::-1])

n = int(input()) 
while n > 0:
    one = input()
    two = input()
    overflow(string_sum(one, two))
    n -= 1

Python: N = int(input())
import re
for _ in [0]*N:
    a = tuple(map(int, input().zfill(100)))
    b = tuple(map(int, input().zfill(100)))
    result = []
    prev = 0
    for i in range(1, 81):
        n = int(a[-i]) + int(b[-i]) + prev
        result.append(n%10)
        prev = n // 10
    if a[-81] + b[-81] + prev > 0:
        print("overflow")
    else:
        print(re.sub(r"^0+", "", "".join(map(str, result[::-1]))))

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(raw_input())
for _ in [0]*n:
  a = int(raw_input())
  b = int(raw_input())
  c = a+b
  print [c,"overflow"][len(str(c))>80]

Python: def digits(n):
    if n < 10: return 1
    c = 0
    while n > 0:
        c += 1
        n = n // 10

    return c

n = int(input())
for i in range(n):
    u = int(input())
    v = int(input())
    s = u + v
    if (digits(u) > 80 or digits(v) > 80 or digits(s) > 80):
        print("overflow")
    else:
        print(s)

Python: n = int(input())
for i in range(n):
    a = int(input())
    b = int(input())
    s = a + b
    if len(str(s)) > 80 :
        print("overflow")
    else:
        print(s)