import std.conv, std.functional, std.range, std.stdio, std.string;
import std.algorithm, std.array, std.bigint, std.bitmanip, std.complex, std.container, std.math, std.mathspecial, std.numeric, std.regex, std.typecons;
import core.bitop;

class EOFException : Throwable { this() { super("EOF"); } }
string[] tokens;
string readToken() { for (; tokens.empty; ) { if (stdin.eof) { throw new EOFException; } tokens = readln.split; } auto token = tokens.front; tokens.popFront; return token; }
int readInt() { return readToken.to!int; }
long readLong() { return readToken.to!long; }
real readReal() { return readToken.to!real; }

bool chmin(T)(ref T t, in T f) { if (t > f) { t = f; return true; } else { return false; } }
bool chmax(T)(ref T t, in T f) { if (t < f) { t = f; return true; } else { return false; } }

int binarySearch(alias pred, T)(in T[] as) { int lo = -1, hi = cast(int)(as.length); for (; lo + 1 < hi; ) { const mid = (lo + hi) >> 1; (unaryFun!pred(as[mid]) ? hi : lo) = mid; } return hi; }
int lowerBound(T)(in T[] as, T val) { return as.binarySearch!(a => (a >= val)); }
int upperBound(T)(in T[] as, T val) { return as.binarySearch!(a => (a > val)); }

struct ModInt(uint M_) {
  import std.conv : to;
  alias M = M_;
  uint x;
  this(ModInt a) { x = a.x; }
  this(uint x_) { x = x_ % M; }
  this(ulong x_) { x = cast(uint)(x_ % M); }
  this(int x_) { x = ((x_ %= cast(int)(M)) < 0) ? (x_ + cast(int)(M)) : x_; }
  this(long x_) { x = cast(uint)(((x_ %= cast(long)(M)) < 0) ? (x_ + cast(long)(M)) : x_); }
  ref ModInt opAssign(T)(inout(T) a) if (is(T == uint) || is(T == ulong) || is(T == int) || is(T == long)) { return this = ModInt(a); }
  ref ModInt opOpAssign(string op, T)(T a) {
    static if (is(T == ModInt)) {
      static if (op == "+") { x = ((x += a.x) >= M) ? (x - M) : x; }
      else static if (op == "-") { x = ((x -= a.x) >= M) ? (x + M) : x; }
      else static if (op == "*") { x = cast(uint)((cast(ulong)(x) * a.x) % M); }
      else static if (op == "/") { this *= a.inv(); }
      else static assert(false);
      return this;
    } else static if (op == "^^") {
      if (a < 0) return this = inv()^^(-a);
      ModInt b = this, c = 1U;
      for (long e = a; e; e >>= 1) { if (e & 1) c *= b; b *= b; }
      return this = c;
    } else {
      return mixin("this " ~ op ~ "= ModInt(a)");
    }
  }
  ModInt inv() const {
    uint a = M, b = x; int y = 0, z = 1;
    for (; b; ) { const q = a / b; const c = a - q * b; a = b; b = c; const w = y - cast(int)(q) * z; y = z; z = w; }
    assert(a == 1); return ModInt(y);
  }
  ModInt opUnary(string op)() const {
    static if (op == "+") { return this; }
    else static if (op == "-") { ModInt a; a.x = x ? (M - x) : 0U; return a; }
    else static assert(false);
  }
  ModInt opBinary(string op, T)(T a) const { return mixin("ModInt(this) " ~ op ~ "= a"); }
  ModInt opBinaryRight(string op, T)(T a) const { return mixin("ModInt(a) " ~ op ~ "= this"); }
  bool opCast(T: bool)() const { return (x != 0U); }
  string toString() const { return x.to!string; }
}

enum MO = 998244353;
alias Mint = ModInt!MO;


enum LIM_INV = 10^^6 + 10;
Mint[] inv, fac, invFac;
void prepare() {
  inv = new Mint[LIM_INV];
  fac = new Mint[LIM_INV];
  invFac = new Mint[LIM_INV];
  inv[1] = 1;
  foreach (i; 2 .. LIM_INV) {
    inv[i] = -((Mint.M / i) * inv[cast(size_t)(Mint.M % i)]);
  }
  fac[0] = invFac[0] = 1;
  foreach (i; 1 .. LIM_INV) {
    fac[i] = fac[i - 1] * i;
    invFac[i] = invFac[i - 1] * inv[i];
  }
}
Mint binom(long n, long k) {
  if (n < 0) {
    if (k >= 0) {
      return (-1)^^(k & 1) * binom(-n + k - 1, k);
    } else if (n - k >= 0) {
      return (-1)^^((n - k) & 1) * binom(-k - 1, n - k);
    } else {
      return Mint(0);
    }
  } else {
    if (0 <= k && k <= n) {
      assert(n < LIM_INV);
      return fac[cast(size_t)(n)] * invFac[cast(size_t)(k)] * invFac[cast(size_t)(n - k)];
    } else {
      return Mint(0);
    }
  }
}


/*
  ###
  ###
  .###
  ...###
  ...###
  ....###
*/
Mint easy001(const(int) M, const(int) N) {
  Mint ret;
  if (M % 3 == 0) {
    const g = gcd(M, N);
    if (g >= 5) {
      ret = 3 * g;
    }
  } else {
    // TODO: o(M + N) ?
    const d1 = (M / 3) * 3 + [0, 0, 1][M % 3];
    const d2 = ((2 * M) / 3) * 3 + [0, 0, 1][(2 * M) % 3];
    auto has = new int[N];
    for (int y = 0; ; ) {
      ++has[y];
      ++has[(y + d1) % N];
      ++has[(y + d2) % N];
      y = (y + 3 * M) % N;
      if (y == 0) break;
    }
    int[] ys;
    foreach (y; 0 .. N) if (has[y]) {
      ys ~= y;
    }
    const ysLen = cast(int)(ys.length);
    bool ok = true;
    foreach (y; 0 .. N) {
      ok = ok && (has[y] <= 1);
    }
    foreach (j; 0 .. ysLen - 1) {
      ok = ok && (ys[j] + 4 <= ys[j + 1]);
    }
    ok = ok && (ys[ysLen - 1] + 4 <= N);
    if (ok) {
      const g = gcd(3 * M, N);
      ret = g;
    }
  }
  debug {
    // writefln("easy001 %s %s = %s", M, N, ret);
  }
  return ret;
}

/*
  ###
  .###
  ..###
  ...###
  ....###
  .....###
*/
Mint easy012(const(int) M, const(int) N) {
  Mint ret;
  const g = gcd(M, N);
  if (g >= 4) {
    ret = g;
  }
  debug {
    writefln("easy112 %s %s = %s", M, N, ret);
  }
  return ret;
}

/*
  ###...##
  ###..###
  .##o.###
  ...ooo..
  ..ooo...
  ###.o##.
  ###..###
  ##...###.o.
         ooo.
         .ooo
         .o..

  ###...##
  ###..###
  .##o.###
  ...ooo..
  ..ooo...
  ###.o##.
  ###..###
  ##...###
         ###
          ###
          ###.o.
            ooo.
            .ooo
            .o..

  f := x^5 / (1 - x^3)
  even: (1/2) (-log(1+f) - log(1-f))
  odd : (1/2) ( log(1+f) - log(1-f))
  
  x(d/dx) log(1+f) = * / (1 - 2 x^3 + x^5 + x^6 - x^8)
  x(d/dx) log(1-f) = * / (1 - 2 x^3 - x^5 + x^6 + x^8)
*/
enum LIM = 10^^6 + 5;
Mint[] gs;
void initHard() {
  Mint[][2] fss;
  fss[0] = new Mint[LIM];
  fss[0][5] = 5;
  fss[0][8] = 8;
  foreach (i; 9 .. LIM) {
    fss[0][i] += 2 * fss[0][i - 3];
    fss[0][i] -= fss[0][i - 5];
    fss[0][i] -= fss[0][i - 6];
    fss[0][i] += fss[0][i - 8];
  }
  fss[1] = new Mint[LIM];
  fss[1][5] = -5;
  fss[1][8] = -8;
  foreach (i; 9 .. LIM) {
    fss[1][i] += 2 * fss[1][i - 3];
    fss[1][i] += fss[1][i - 5];
    fss[1][i] -= fss[1][i - 6];
    fss[1][i] -= fss[1][i - 8];
  }
  gs = new Mint[LIM];
  foreach (i; 0 .. LIM) {
    const Mint f0 = fss[0][i];
    const Mint f1 = fss[1][i];
    gs[i] += (inv[2] * (-f0 - f1))^^2;
    gs[i] += (inv[2] * ( f0 - f1))^^2;
    gs[i] *= 4;
  }
  debug {
    static foreach (s; 0 .. 2) {
      writeln("fss[s] = ", fss[s][0 .. 31]);
    }
    writeln("gs = ", gs[0 .. 31]);
  }
}
Mint hard(const(int) M, const(int) N) {
  Mint ret;
  const g = gcd(M, N);
  if (g % 2 == 0) {
    ret = gs[g / 2];
  }
  debug {
    writefln("hard %s %s = %s", M, N, ret);
  }
  return ret;
}

void main() {
  prepare;
  initHard;
  
  debug {
    enum lim = 30;
    foreach (M; 4 .. lim + 1) {
      foreach (N; 4 .. lim + 1) {
        writef("%3d ", easy001(M, N).x);
      }
      writeln;
    }
  }
  
  try {
    for (; ; ) {
      const numCases = readInt;
      foreach (caseId; 0 .. numCases) {
        const M = readInt;
        const N = readInt;
        
        Mint ans;
        ans += 1L * M * N;
        if (M % 4 == 0 && N % 4 == 0) {
          ans += 16;
        }
        ans += 2 * easy001(M, N);
        ans += 2 * easy012(M, N);
        ans += hard(M, N);
        writeln(ans);
      }
    }
  } catch (EOFException e) {
  }
}