#include <algorithm>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;

using Digits = vector<int>; // 下标 i 保存十进制的 10^i 位。

void trim(Digits &a) {
    while (a.size() > 1 && a.back() == 0) {
        a.pop_back(); // 删除多余高位零，但给数字 0 留下一位。
    }
}

Digits readDigits(const string &s) {
    Digits a;
    for (int i = static_cast<int>(s.size()) - 1; i >= 0; --i) {
        a.push_back(s[i] - '0'); // 字符 '7' 转成数字 7，低位先存。
    }
    trim(a);
    return a;
}

string writeDigits(const Digits &a) {
    string s;
    for (int i = static_cast<int>(a.size()) - 1; i >= 0; --i) {
        s.push_back(static_cast<char>('0' + a[i])); // 高位先输出。
    }
    return s;
}

int compare(const Digits &a, const Digits &b) {
    if (a.size() != b.size()) {
        return a.size() > b.size() ? 1 : -1; // 位数多的绝对值大。
    }
    for (int i = static_cast<int>(a.size()) - 1; i >= 0; --i) {
        if (a[i] != b[i]) {
            return a[i] > b[i] ? 1 : -1; // 第一处不同的高位决定大小。
        }
    }
    return 0; // 每一位都相同。
}

Digits addMagnitude(const Digits &a, const Digits &b) {
    Digits result;
    int n = static_cast<int>(max(a.size(), b.size()));
    int carry = 0;
    for (int i = 0; i < n || carry != 0; ++i) {
        int sum = carry;
        if (i < static_cast<int>(a.size())) sum += a[i];
        if (i < static_cast<int>(b.size())) sum += b[i];
        result.push_back(sum % 10); // 当前位留下个位部分。
        carry = sum / 10; // 十位部分成为下一格的进位。
    }
    return result;
}

Digits subtractMagnitude(const Digits &a, const Digits &b) {
    Digits result;
    int borrow = 0;
    for (int i = 0; i < static_cast<int>(a.size()); ++i) {
        int difference = a[i] - borrow;
        if (i < static_cast<int>(b.size())) difference -= b[i];
        borrow = difference < 0 ? 1 : 0;
        if (borrow != 0) difference += 10; // 从下一格借来一个十。
        result.push_back(difference);
    }
    trim(result); // 1000-728 的末尾零、相等两数相减的高位零都在这里整理。
    return result;
}

Digits multiplyMagnitude(const Digits &a, const Digits &b) {
    Digits result(a.size() + b.size(), 0);
    for (int i = 0; i < static_cast<int>(a.size()); ++i) {
        int carry = 0; // 每一行从自己的起点开始进位。
        for (int j = 0; j < static_cast<int>(b.size()); ++j) {
            int sum = result[i + j] + a[i] * b[j] + carry;
            result[i + j] = sum % 10; // 边累加边整理为一个数字位。
            carry = sum / 10;
        }
        result[i + b.size()] = carry; // 本行多出的最高位还没有被前面的行写入。
    }
    trim(result);
    return result;
}

pair<Digits, Digits> divideMagnitude(const Digits &a, const Digits &b) {
    Digits quotient(a.size(), 0);
    Digits remainder{0};
    for (int i = static_cast<int>(a.size()) - 1; i >= 0; --i) {
        remainder.insert(remainder.begin(), a[i]); // 余数乘 10，再接入下一位。
        trim(remainder);
        int digit = 0;
        while (compare(remainder, b) >= 0) {
            remainder = subtractMagnitude(remainder, b);
            ++digit; // 每减去一次除数，本位商加一。
        }
        quotient[i] = digit; // 该商位对应被除数当前的十进制位权。
    }
    trim(quotient);
    return {quotient, remainder}; // 同一次长除法同时得到商和余数。
}

pair<Digits, long long> divideByInt(const Digits &a, int b) {
    Digits quotient(a.size(), 0);
    long long remainder = 0;
    for (int i = static_cast<int>(a.size()) - 1; i >= 0; --i) {
        long long current = remainder * 10 + a[i];
        quotient[i] = static_cast<int>(current / b); // 直接确定本位商。
        remainder = current % b; // 留给下一位的余数。
    }
    trim(quotient);
    return {quotient, remainder};
}

struct BigInteger {
    Digits digits;
    bool negative = false; // true 表示负数，digits 只保存绝对值。
};

bool isZero(const Digits &a) {
    return a.size() == 1 && a[0] == 0;
}

BigInteger makeInteger(Digits digits, bool negative) {
    if (isZero(digits)) negative = false; // 所有运算得到的零都去掉负号。
    return {digits, negative};
}

BigInteger readInteger(const string &s) {
    bool negative = s[0] == '-';
    int firstDigit = (s[0] == '-' || s[0] == '+') ? 1 : 0;
    return makeInteger(readDigits(s.substr(firstDigit)), negative);
}

string writeInteger(const BigInteger &a) {
    return (a.negative ? "-" : "") + writeDigits(a.digits);
}

BigInteger addInteger(const BigInteger &a, const BigInteger &b) {
    if (a.negative == b.negative) {
        return makeInteger(addMagnitude(a.digits, b.digits), a.negative);
    }
    int order = compare(a.digits, b.digits);
    if (order >= 0) {
        // 异号相抵，幅度较大的 a 决定结果符号。
        return makeInteger(subtractMagnitude(a.digits, b.digits), a.negative);
    }
    return makeInteger(subtractMagnitude(b.digits, a.digits), b.negative);
}

BigInteger subtractInteger(const BigInteger &a, BigInteger b) {
    if (!isZero(b.digits)) b.negative = !b.negative;
    return addInteger(a, b); // A-B 等于 A+(-B)，复用已推导的加法。
}

BigInteger multiplyInteger(const BigInteger &a, const BigInteger &b) {
    return makeInteger(multiplyMagnitude(a.digits, b.digits),
                       a.negative != b.negative); // 异号相乘得到负数。
}

pair<BigInteger, BigInteger> divideInteger(const BigInteger &a,
                                          const BigInteger &b) {
    auto [quotient, remainder] = divideMagnitude(a.digits, b.digits);
    return {makeInteger(quotient, a.negative != b.negative),
            makeInteger(remainder, a.negative)}; // 余数随被除数符号，零由统一函数整理。
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int t;
    cin >> t;
    while (t--) {
        char operation;
        string first, second;
        cin >> operation >> first >> second; // 超长整数先按文本读入。
        BigInteger a = readInteger(first);
        BigInteger b = readInteger(second);
        if (operation == '+') {
            cout << writeInteger(addInteger(a, b)) << '\n';
        } else if (operation == '-') {
            cout << writeInteger(subtractInteger(a, b)) << '\n';
        } else if (operation == '*') {
            cout << writeInteger(multiplyInteger(a, b)) << '\n';
        } else if (isZero(b.digits)) {
            cout << "DIV0\n"; // 除数 0 在进入长除法前单独输出。
        } else {
            auto [quotient, remainder] = divideInteger(a, b);
            cout << writeInteger(quotient) << ' '
                 << writeInteger(remainder) << '\n';
        }
    }
}