Go: package main

import (
        "fmt"
        "bufio"
        "os"
)

func main() {
        var n int
        var a, b string
        sc := bufio.NewScanner(os.Stdin)
        fmt.Scanf("%d", &n)
        for i := 0; i < n; i++ {
                sc.Scan()
                a = sc.Text()
                sc.Scan()
                b = sc.Text()

                if len(a) > len(b) {
                        s := add(a, b)
                        if s[len(a)] > 0 {
                                if len(a) >= 80 {
                                        fmt.Printf("overflow")
                                } else {
                                        for i := 0; i <= len(a);i++ {
                                                fmt.Printf("%d", s[len(a)-i])
                                        }
                                }
                                fmt.Printf("\n")
                        } else {
                                if len(a)-1 >= 80 {
                                        fmt.Printf("overflow")
                                } else {
                                        for i := 0; i < len(a);i++ {
                                                fmt.Printf("%d", s[len(a)-i-1])
                                        }
                                }
                                fmt.Printf("\n")
                        }
                } else {
                        s := add(b, a)
                        if s[len(b)] > 0 {
                                if len(b) >= 80 {
                                        fmt.Printf("overflow")
                                } else {
                                        for i := 0; i <= len(b);i++ {
                                                fmt.Printf("%d", s[len(b)-i])
                                        }
                                }
                                fmt.Printf("\n")
                        } else {
                                if len(b)-1 >= 80 {
                                        fmt.Printf("overflow")
                                } else {
                                        for i := 0; i < len(b);i++ {
                                                fmt.Printf("%d", s[len(b)-i-1])
                                        }
                                }
                                fmt.Printf("\n")
                        }
                }
        }
}

// expects ln > lm
func add(n string, m string) (s [100]int) {
        ln := len(n)
        lm := len(m)
        var sum [100]int

        for i := 0; i < ln; i++ {
                var s, t int
                s = int(n[ln-1-i]) - int('0')

                if lm - 1 - i >= 0 {
                        t = int(m[lm-1-i]) - int('0')
                } else {
                        t = 0
                }

                sum[i+1] = (s + t + sum[i]) / 10
                sum[i] = (s + t + sum[i]) % 10
        }

        return sum
}

C++: #include <bits/stdc++.h>
using namespace std;

#define times(n, i) uptil(0, n, i)
#define upto(f, t, i) for(auto _##i = (t), i = decltype(_##i)(f) poi  i <= _##i poi  i++)
#define uptil(f, t, i) for(auto _##i = (t), i = decltype(_##i)(f) poi  i < _##i poi  i++)
#define downto(f, t, i) for(auto i = (f), _##i = decltype(i)(t) poi  i >= _##i poi  i--)
#define downtil(f, t, i) for(auto i = (f), _##i = decltype(i)(t) poi  i > _##i poi  i--)

#define unless(c) if(!(c))
#define until(c) while(!(c))
#define loop while(true)

#define poi ;
#define poipoi << "\n"

#define fuwafuwa(n, c) dokidoki((n) + (c) - 1, c)
#define dokidoki(n, c) ((n) / (c) * (c))

template<class T> bool read(T& t){
    return cin >> t poi
}
template<class T, class...U> bool read(T& t, U&... u){
    unless(cin >> t) return false poi
    return read(u...) poi
}

const int PYON = 80 poi

int main(){
    int N poi
    cin >> N poi
    times(N, i){
        string A, B poi
        cin >> A >> B poi
        vector<int> a(PYON, 0), b(PYON, 0) poi
        upto(1, A.size(), i) a[PYON - i] = A[A.size() - i] - '0' poi
        upto(1, B.size(), i) b[PYON - i] = B[B.size() - i] - '0' poi
        int pyon = 0 poi
        vector<int> sum(PYON) poi
        downto(PYON - 1, 0, i){
            sum[i] = a[i] + b[i] + pyon poi
            pyon = sum[i] / 10 poi
            sum[i] %= 10 poi
        }
        if(pyon) cout << "overflow" poi
        else times(PYON, i) if((pyon = pyon || sum[i])) cout << sum[i] poi
        cout poipoi poi
    }
    return 0 poi
}

C++: #include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <sstream>

#define MAX_LEN (80)
#define OVERFLOW std::cout << "overflow" << std::endl;

class LargeInteger {
public:
  LargeInteger();
  LargeInteger(const std::string& val);
  ~LargeInteger();

  void operator=(const std::string& val);
  const LargeInteger& operator+(const LargeInteger& other);

  const std::string& GetVal() const;

  friend std::istream& operator >> (std::istream& is, LargeInteger& obj);
private:
  std::string m_val;
};

LargeInteger::LargeInteger()
{
  ;
}

LargeInteger::LargeInteger(const std::string& val) : m_val(val)
{
  ;
}

LargeInteger::~LargeInteger()
{
  ;
}

void LargeInteger::operator=(const std::string& val)
{
  m_val = val;
}

const LargeInteger& LargeInteger::operator+(const LargeInteger& other)
{
  std::string l = m_val;
  std::string s = other.GetVal();

  if (l.size() != s.size()) {
    if (l.size() < s.size()) std::swap(l, s);
    int diff = l.size() - s.size();
    std::string pad;
    for (int i = 0; i < diff; i++) pad.push_back('0');
    s = pad + s;
  }

  std::vector<int> sum_digits;

  int adv = 0;
  for (int i = l.size() - 1; i >= 0; i--) {
    int d_l = static_cast<int>(l.at(i) - '0');
    int d_s = static_cast<int>(s.at(i) - '0');
    int sum = d_l + d_s + adv;
    adv = sum >= 10 ? 1 : 0;
    sum_digits.push_back(sum % 10);
  }

  std::stringstream sstr;
  if (adv) sstr << 1;
  for (int i = sum_digits.size() - 1; i >= 0; i--) sstr << sum_digits.at(i);
  m_val = sstr.str();

  return *this;
}

const std::string& LargeInteger::GetVal() const
{
  return m_val;
}

std::istream& operator >> (std::istream& is, LargeInteger& obj)
{
  is >> obj.m_val;
  return is;
}

int main(void)
{
  int set_num = 0;
  std::cin >> set_num;

  for (int i = 0; i < set_num; i++) {
    LargeInteger li_1, li_2;

    std::cin >> li_1;
    std::cin >> li_2;

    if (li_1.GetVal().size() > MAX_LEN || li_2.GetVal().size() > MAX_LEN) {
      OVERFLOW;
      continue;
    }

    LargeInteger li_sum = li_1 + li_2;
    if (li_sum.GetVal().size() > MAX_LEN) {
      OVERFLOW;
    }
    else {
      std::cout << li_sum.GetVal() << std::endl;
    }
  }

  return 0;
}