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

typedef pair<long, long> iPair;

struct Graph
{
    long V, E;
    vector<pair<long, iPair>> edges;

    Graph(long V, long E)
    {
        this->V = V;
        this->E = E;
    }

    void addEdge(long u, long v, long w)
    {
        edges.push_back({w, {u, v}});
    }

    long kruskalMST();
};

struct DisjointSets
{
    long *parent, *rnk;
    long n;

    DisjointSets(long n)
    {
        this->n = n;
        parent = new long[n + 1];
        rnk = new long[n + 1];

        for (long i = 0; i <= n; i++)
        {
            rnk[i] = 0;

            parent[i] = i;
        }
    }

    long find(long u)
    {
        if (u != parent[u])
            parent[u] = find(parent[u]);
        return parent[u];
    }

    void merge(long x, long y)
    {
        x = find(x), y = find(y);

        if (rnk[x] > rnk[y])
            parent[y] = x;
        else
            parent[x] = y;

        if (rnk[x] == rnk[y])
            rnk[y]++;
    }
};

long Graph::kruskalMST()
{
    long mst_wt = 0;

    sort(edges.begin(), edges.end());

    DisjointSets ds(V);

    vector<pair<long, iPair>>::iterator it;
    for (it = edges.begin(); it != edges.end(); it++)
    {
        long u = it->second.first;
        long v = it->second.second;

        long set_u = ds.find(u);
        long set_v = ds.find(v);

        if (set_u != set_v)
        {
            mst_wt += it->first;

            ds.merge(set_u, set_v);
        }
    }

    return mst_wt;
}

// bool isPalindrome(string s)
// {
//     for (auto i = 0; i < s.length() / 2; i++)
//     {
//         if (s[i] != s[s.length() - 1 - i])
//         {
//             return false;
//         }
//     }
//     return true;
// }

// string newString(int opt, string s, long i)
// {
//     string s_;
//     if (opt == 0)
//     {
//         for (auto j = i; j >= 1; j--)
//         {
//             s_.push_back(s[i]);
//         }
//         s = s_ + s;
//     }
//     else
//     {
//         for (auto j = s.length() - 2; j >= i; j--)
//         {
//             s_.push_back(s[i]);
//         }
//         s = s + s_;
//     }
//     return s;
// }

// {
//     if (x % 2)
//         return 0;
//     return 1;
// }
// long unsigned modularInverse(long unsigned a, long unsigned y, long unsigned m)
// {
//     if (y == 0)
//         return 1;
//     long unsigned p = modularInverse(a, y / 2, m) % m;
//     p = p * p % m;
//     return (y % 2 == 0) ? p : a * p % m;
// }

// long unsigned modInv(long unsigned a, long unsigned m)
// {
//     return modularInverse(a, m - 2, m);
// }

// long factorial(int x)
// {
//     if (x == 1 || x == 0)
//         return 1;
//     return x * factorial(x - 1);
// }

// long MOD = 1000000007;

int main()
{
    long long n, t, m, k, ai, x, y;
    cin >> t;
    while (t--)
    {
        cin >> x >> y;
        long v = abs(y - 0);
        long h = abs(x - 0);
        if (v == h)
            cout << max(v, h) * 2 << endl;
        else
            cout << max(v, h) * 2 - 1 << endl;
    }
    return 0;
}
