#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;
}