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: a=int(input())
b=int(input())
c=a+b
c=str(c)
if len(c)>80:
	print("overflow")
else:
	print(c)

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: if __name__ == "__main__":
    nset = int(input())

    for i in range(0,nset):
        a = int(input())
        b = int(input())
        print(a+b)

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

Python: upper = 10**81
n = int(input())
for i in range(n):
    n1 = int(input())
    if n1 >= upper:
        print("overflow")
        continue
    n2 = int(input())
    if n2 >= upper:
        print("overflow")
        continue
    print( n1 + n2 if n1+n2 < upper else "overflow")

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

import sys
import math

n = int(input())
anss = []

for _ in range(n):
    x = int(input())
    y = int(input())
    anss.append(x+y)

for data in anss:
    print(data)

Python: print("In preparation.")

Python: n = int(input())
for i in range(n):
    num1 = int(input())
    num2 = int(input())
    num3 = num1 + num2
    k = len(str(num3))
    if k > 80:
        print("overflow")
    else:
        print(num3)

Python: upper = 10**80
n = int(input())
for i in range(n):
    n1 = int(input())
    if n1 >= upper:
        print("overflow")
        continue
    n2 = int(input())
    if n2 >= upper:
        print("overflow")
        continue
    print( n1 + n2 if n1+n2 < upper else "overflow")

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

import sys
import math

n = int(input())
anss = []

for _ in range(n):
    x = int(input())
    y = int(input())
    if int(math.log10(x)+1) > 80:
        print("overflow")
    elif int(math.log10(y)+1) > 80:
        print("overflow")
    elif int(math.log10(x+y)+1) > 80:
        print("overflow")
    else:
        anss.append(x+y)

for data in anss:
    print(data)

Python: n=int(input())
A=[]
while True:
	try:
		x=int(input())
		A.append(x)
	except EOFError:
		break
start=0
end=start+n
for i in range(len(A)//n):
	s=sum(A[start:end])
	if s/1e80>1:
		print("overflow")
	else:
		print(s)
	start+=n
	end+=n

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(budget)
    else:
        print('overflow')

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

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

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

Python: m = 100000000000000000000000000000000000000000000000000000000000000000000000000000000
n = int(input())
for i in range(n):
    a = int(input())
    b = int(input())
    sum = a + b
    if sum > m or sum == m:
        print("overflow")
    else:
        print(sum)

Python: n=input()
for i in range(n):
	a=input()
	b=input()
	print(a+b)

Python: def f(): return int(raw_input())
n = f()
for _ in [0]*n:
  a = f()
  b = f()
  c = a+b
  print [c, "overflow"][len(str(c))>80]

Python: import math

n = int(input())

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

Python: n = input()
for _ in [0]*n:
  a = input()
  b = input()
  c = a+b
  print [c,"overflow"][len(str(c))>80]

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

import math

BIG_NUM = 100000000000000000000000000000000000000000000000000000000000000000000000000000000


def main():
    n = int(input())
    for _ in range(n):
        a = int(input())
        b = int(input())
        if a >= BIG_NUM  or b >= BIG_NUM or a + b >= BIG_NUM:
            print("overflow")
        else:
            print(a+b)

if __name__ == "__main__":
    main()

Python: import sys
N=int(input())
N=int(N/2)
for i in range(N):
    a=input()
    b=input()
    len_a=len(a)
    len_b=len(b)
    c=[]
    kuriage=0
    if(len_a>=len_b):
        for i in range(len_b):
            c.append((kuriage+int(a[len_a-1-i])+int(b[len_b-1-i]))%10)
            kuriage=(kuriage+int(a[len_a-1-i])+int(b[len_b-1-i]))//10
        for i in range(len_b,len_a):
            c.append((kuriage+int(a[len_a-1-i]))%10)
            kuriage=(kuriage+int(a[len_a-1-i]))//10



    else :
        for i in range(len_a):
            c.append((kuriage+int(a[len_a-1-i])+int(b[len_b-1-i]))%10)
            kuriage=(kuriage+int(a[len_a-1-i])+int(b[len_b-1-i]))//10
        for i in range(len_a,len_b):
            c.append((kuriage+int(b[len_b-1-i]))%10)
            kuriage=(kuriage+int(b[len_b-1-i]))//10

    if(kuriage==1):
        c.append(1)

    if(len(c)>=80):
        print('overflow')

    else:
        for i in c[::-1]:
            print(i,end='')
        print('')

Python: num_datasets = int(input())

for i in range(num_datasets):
    n = input().strip()
    m = input().strip()
    first_num_str = ""
    second_num_str = ""
    if len(n) > len(m):
        first_num_str = n
        second_num_str = m
    else:
        first_num_str = m
        second_num_str = n
    total = ""
    carry = 0
    first_int = 0
    second_int = 0
    first_last_index = len(first_num_str)-1
    second_last_index = len(second_num_str)-1
    for i in range(len(first_num_str)):
        first_int = int(first_num_str[first_last_index-i])
        if i < len(second_num_str):
            second_int = int(second_num_str[second_last_index-i])
        else:
            second_int = 0
        added = (first_int + second_int + carry) % 10
        carry = (first_int + second_int + carry) // 10
        total = str(added) + total
    if carry > 0:
        total = str(carry) + total
    if len(total) > 80:
        print("overflow")
    else:
        print(total)

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

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