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: 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())
	print(a+b)

Python: for _ in range(int(input())):
    a, b = input(), input()
    if len(a) < 81 and len(b) < 81 :
        c = int(a) + int(b)
        if len(str(c)) < 81 : print(c)
        else : print('overflow')
    else : print('overflow')

Python: import math
count=int(input())
for i in range(count):
    x=int(input())
    y=int(input())
    ans=x+y
    dif=100000000000000000000000000000000000000000000000000000000000000000000000000000000
    if ans>=dif:
        print("overflow")
    else:
        print(ans)

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

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

Python: i = int(input())
for n in range(i):
    j = int(input())
    k = int(input())
    if len(str(j + k)) > 80:
        print("overflow")
    elif len(str(j)) or len(str(k)):
        print("overflow")
    else:
         print(j + k)

Python: n = int(input())
for _ in range(n):
    a = sum([int(input()) for _ in range(n)])
    print(a if a < 10**80 else 'overflow')

Python: if __name__ == '__main__':
    # ??????????????\???
    loop = int(input())
    for i in range(loop):
        num1 = int(input())
        num2 = int(input())

        # ???????????????
        result = num1 + num2

        # ???????????????
        if len(str(result)) > 80:
            print('overflow')
        else:
            print(result)

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

Python: n = int(input())

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

Python: import math
n = input();
for var in range(0, int(n)) :
	c1 = input();
	c2 = input();
	sum = int(c1) + int(c2);
	if(math.log10(sum) + 1 > 80) :
		print("overflow");
	else :
		print(sum);

Python: n = int(input())
for i in range(n):
    s = int(input()) + int(input())
    if(len(str(s)) <= 80):
        print (s)
    else:
        print ('overflow')

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

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

Python: # -*- coding: utf-8 -*-

import sys
import os
import math

def is_overflow(v):
    s = str(v)
    if len(s) > 80:
        return True
    else:
        return False

N = int(input())
for i in range(N):
    v0 = int(input())
    v1 = int(input())
    if is_overflow(v0) or is_overflow(v1):
        print('overflow')
    elif is_overflow(v0 + v1):
        print('overflow')
    else:
        print(v0 + v1)

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

lim = 1000000000000000000000000000000000000000000000000000000000000000000000000000000 

def largeBudget(a, b):
  if a >= lim or b >= lim: print("overflow")
  elif a+b >= lim: print("overflow")
  else: print("%d"%(a+b))

N = int(input())
for i in range(N):
  a = int(input())
  b = int(input())
  largeBudget(a, b)

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

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()
        if len(sumstr) == 0:
            sumstr = "0"

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

Python: import math

n = int(input());

for i in range(0,n):
    
    num1 = int(input());
    num2 = int(input());
    total = num1 + num2;

    if len(str(total)) > 80:
        print("overflow");
    else:
        print(total);

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

Python: for i in range(int(input())):
    try:
        a = sum([int(j) for j in input().split()])
    except:
        print("overflow")
    else:
        print(a)

Python: import math
a=int(input())
b=int(input())
c=a+b
for x in range(80):
	c=math.floor(c/10)
if(c>=1):
	print("overflow")
else:
	print(a+b)

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

Python: import sys
import math

n = int(sys.stdin.readline())

for i in range(n):
    n1 = int(sys.stdin.readline())
    n2 = int(sys.stdin.readline())
    if n1+n2<100000000000000000000000000000000000000000000000000000000000000000000000000000000 :
        print(n1+n2)
    else:
        print("overflow")

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

Python: import math

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