#ifdef LOCAL
#include "stdafx.h"
#else
#include <bits/stdc++.h>
#define IL inline
#define LL long long
#define eb emplace_back
#define sz(v) ((int) (v).size())
#define me(f, x) memset(f, x, sizeof(f))
#define mc(f, g) memcpy(f, g, sizeof(g))
#define L(i, j, k) for (int i = (j); i <= (k); ++i)
#define R(i, j, k) for (int i = (j); i >= (k); --i)
#define FIO(FILE) freopen(FILE".in", "r", stdin), freopen(FILE".out", "w", stdout)
using namespace std;

using vi = vector<int>;
#endif

namespace Math {
  constexpr int P = 998244353;
  constexpr int G = 3;

  #ifdef _WIN32
  using uint = uint32_t;
  #endif
  using ull = uint64_t;
  
  using cint = const int;

  template<class T>
  IL void qm (T &x) {
    x += (x >> 31) & P; 
  }
  template<class T>
  IL T nor (const T &x) { 
    return x + ((x >> 31) & P); 
  }
  template<class T>
  IL T fix (T x) { 
    return nor(x %= P); 
  }

  IL int qpow (int b, int k) {
    int r = 1;
    for (; k; k >>= 1, b = (ull)b * b % P) if (k & 1) r = (ull)r * b % P;
    return r;
  }

  namespace FFT {
    constexpr int N = 1 << 20;
    int n, lg, root[N];
    
    IL void init (cint z) {
      n = 1, lg = 0;
      while (n <= z) {
        n <<= 1;
        ++lg;
      }
      assert(n <= N);
      ull w = qpow(G, (P - 1) / n);
      root[0] = 1;
      for (int i = 1; i < n; ++i) {
        root[i] = root[i - 1] * w % P;
      }
    }

    template<typename T>
    IL void DIF (T *a) {
      static int *i, *j;
      for (int l = n; l > 1; l >>= 1) {
        cint m = l >> 1;
        for (i = a; i != a + n; i += l) {
          int *w = root;
          for (j = i; j != i + m; ++j, w += n / l) {
            T t = nor(*j + j[m] - P);
            j[m] = (ull)*w * (*j - j[m] + P) % P;
            *j = t;
          }
        }
      }
    }

    template<typename T>
    IL void DIT (T *a) {
      static int *i, *j;
      for (int l = 2; l <= n; l <<= 1) {
        cint m = l >> 1;
        for (i = a; i != a + n; i += l) {
          int *w = root;
          for (j = i; j != i + m; ++j, w += n / l) {
            T t = (ull)*w * j[m] % P;
            qm(j[m] = *j - t);
            qm(*j += t - P);
          }
        }
      }
      T iv = P - (P - 1) / n;
      reverse(a + 1, a + n);
      for (int i = 0; i < n; i++) {
        a[i] = (ull)a[i] * iv % P;
      }
    }
  }

  using FFT::init;
  using FFT::DIF;
  using FFT::DIT;

  struct Poly {
    vector<int> a;

    Poly () : a(1) {}

    Poly (int v) { fix(v); a = {v}; }

    Poly (vector<int> &a) : a(a) {}
    Poly (initializer_list<int> a) : a(a) {}

    int operator [] (uint p) const {
      return p < a.size() ? a[p] : 0;
    }
    int& operator [] (uint p) {
      return p < a.size() ? a[p] : (a.resize(p + 1), a[p]);
    }

    const size_t deg () const { return a.size() - 1; }
    const size_t size () const { return a.size(); }
    int *base () { return a.data(); }
    cint *base () const { return a.data(); }
    void redeg (size_t d) { a.resize(d + 1); }
    void resize (size_t sz) { a.resize(sz); }

    Poly slice (int d) const {
      if (d < (int)(a.size())) {
        vector<int> r(a.begin(), a.begin() + d);
        return r;
      }
      vector<int> r(a);
      r.resize(d);
      return r;
    }

    Poly operator + (const Poly &z) const {
      vector<int> r(max(a.size(), z.a.size()));
      for (int i = 0; i < (int)(r.size()); i++) {
        qm(r[i] = operator[](i) + z[i] - P);
      }
      return r;
    }

    Poly operator - (const Poly &z) const {
      vector<int> r(max(a.size(), z.a.size()));
      for (int i = 0; i < (int)(r.size()); i++) {
        qm(r[i] = operator[](i) - z[i]);
      }
      return r;
    }

    Poly operator - () const {
      vector<int> r(a);
      for (auto &v : r) {
        if (v) {
          v = P - v;
        }
      }
      return r;
    }

    Poly deriv () const {
      int _n = deg();
      if (!_n) {
        return 0;
      } else {
        vector<int> r(_n);
        for (int i = 0; i < _n; i++) {
          r[i] = (ull)a[i + 1] * (i + 1) % P;
        }
        return r;
      }
    }

    Poly integ () const {
      static vector<int> iv{0, 1};
      int _n = size();
      if (_n >= (int)(iv.size())) {
        int _m = iv.size();
        iv.resize(_n + 1);
        for (int i = _m; i <= _n; i++) {
          iv[i] = (ull)iv[P % i] * (P - P / i) % P;
        }
      }
      vector<int> r(_n + 1);
      for (int i = 1; i <= _n; i++) {
        r[i] = (ull)a[i - 1] * iv[i] % P;
      }
      return r;
    }

    Poly T () const {
      Poly z = *this;
      reverse(z.a.begin(), z.a.end());
      return z;
    }

    Poly operator * (const Poly &z) const;

    Poly inv () const;

    Poly operator / (const Poly &z) const {
      size_t n = deg(), m = z.deg();
      if (n < m) {
        return Poly();
      }
      Poly F = T(), G = z.T();
      F.redeg(n - m), G.redeg(n - m);
      Poly Q = F * G.inv();
      Q.redeg(n - m);
      return Q.T();
    }

    Poly operator % (const Poly &z) const {
      Poly R = *this - *this / z * z;
      R.resize(z.deg());
      return R;
    }
    
    Poly& operator += (const Poly &z) { (*this) = (*this) + z; return *this; }
    Poly& operator -= (const Poly &z) { (*this) = (*this) - z; return *this; }
    Poly& operator *= (const Poly &z) { (*this) = (*this) * z; return *this; }
    Poly& operator /= (const Poly &z) { (*this) = (*this) / z; return *this; }
    Poly& operator %= (const Poly &z) { (*this) = (*this) % z; return *this; }

    Poly ln () const;
    Poly exp () const;
    Poly sqrt () const;

    Poly pow (int k) const {
      Poly b = *this, r = 1;
      for (; k; k >>= 1, b *= b) if (k & 1) r *= b;
      return r;
    }
  };

  IL Poly _bfmul (const Poly &a, const Poly &b) {
    int n = a.size(), m = b.size();
    vector<int> c(n + m - 1);
    for (int i = 0; i < n; i++) {
      if (a[i]) {
        for (int j = 0; j < m; j++) {
          c[i + j] = (c[i + j] + (ull)a[i] * b[j]) % P;
        }
      }
    }
    return c;
  }

  IL Poly _mul (Poly a, Poly b) {
    int n = a.size() + b.size() - 1;
    FFT::init(n);
    int _n = FFT::n;
    a.resize(_n);
    b.resize(_n);
    DIF(a.base());
    DIF(b.base());
    Poly c(a);
    for (int i = 0; i < _n; i++) {
      c[i] = (ull)c[i] * b[i] % P;
    }
    DIT(c.base());
    c.resize(n);
    return c;
  }

  Poly Poly::operator* (const Poly &z) const {
    int n = a.size(), m = z.size();
    if (n <= 32 || m <= 32) {
      return _bfmul(*this, z);
    } else {
      return _mul(*this, z);
    }
  }

  namespace internal {
    namespace Cipolla {
      int w;
      struct Complex {
        int r, i;
        Complex (int r = 0, int i = 0) : r(r), i(i) {}
        Complex operator * (const Complex &rhs) const {
          return Complex(((LL)r * rhs.r + (LL)i * rhs.i % P * w) % P, 
            ((LL)r * rhs.i + (LL)i * rhs.r) % P);
        }
        Complex pow (int k) const {
          Complex r(1, 0), b(*this);
          for (; k; k >>= 1, b = b * b) if (k & 1) r = r * b;
          return r;
        }
      };

      mt19937 rng(random_device{}());

      int Cipolla (int a) {
        int b;
        do {
          b = rng() % P;
          w = ((LL)b * b + P - a) % P;
        } while (b == 0 || qpow(w, (P - 1) / 2) == 1);
        int z = Complex(b, 1).pow((P + 1) / 2).r;
        return min(z, P - z);
      }
    }
  }

  namespace Newton {
    using FFT::init;
    using FFT::DIF;
    using FFT::DIT;

    IL void inv (const Poly &f, Poly &g, cint l) {
      if (l == 1) {
        g = qpow(f[0], P - 2);
        return;
      }
      inv(f, g, (l + 1) >> 1);
      init(l << 1);
      int _n = FFT::n;
      Poly a = f.slice(l), b = g.slice(l);
      a.resize(_n);
      b.resize(_n);
      DIF(a.base());
      DIF(b.base());
      vector<int> c(_n);
      for (int i = 0; i < _n; i++) {
        qm(c[i] = (int)((2 - (LL)a[i] * b[i]) % P * b[i] % P));
      }
      DIT(c.data());
      g = Poly(c).slice(l);
    }
    
    IL void exp (const Poly &f, Poly &g, cint l) {
      if (l == 1) {
        assert(f[0] == 0);
        g = 1;
        return;
      }
      exp(f, g, (l + 1) >> 1);
      Poly a = f.slice(l), b = g.slice(l);
      Poly c = b * (Poly(1) - b.ln() + a);
      g = c.slice(l);
    }

    IL void sqrt (const Poly &f, Poly &g, cint l) {
      if (l == 1) {
        g = internal::Cipolla::Cipolla(f[0]);
        return;
      }
      sqrt(f, g, (l + 1) >> 1);
      Poly a = f.slice(l), b = g.slice(l);
      Poly c = (a + b * b) * (b * 2).inv();
      g = c.slice(l);
    }
  }

  Poly Poly::inv () const {
    Poly s;
    Newton::inv(*this, s, size());
    return s;
  }

  Poly Poly::ln () const {
    assert(a[0] == 1);
    Poly s = (deriv() * inv()).integ();
    s.redeg(deg());
    return s;
  }

  Poly Poly::exp () const {
    Poly s;
    Newton::exp(*this, s, size());
    return s;
  }

  Poly Poly::sqrt() const {
    assert(qpow(a[0], (P - 1) / 2) == 1);
    Poly s;
    Newton::sqrt(*this, s, size());
    return s;
  }

  namespace Ext {
    vector<int> _eval (const Poly &f, const vector<int> &a, cint &n) {
      static Poly t[1 << 20];
      
      auto mul = [] (Poly a, Poly b) {
        int n = a.size(), m = b.size();
        reverse(b.a.begin(), b.a.end());
        b *= a;
        for (int i = 0; i < n; ++i) {
          a[i] = b[m + i - 1];
        }
        return a;
      };

      auto dfs = [&] (auto self, int l, int r, int p) -> void {
        if (r - l == 1) {
          t[p] = {1, P - a[l]};
          return;
        }
        int m = (l + r) >> 1;
        self(self, l, m, p << 1);
        self(self, m, r, p << 1 | 1);
        t[p] = t[p << 1] * t[p << 1 | 1];
      };
      dfs(dfs, 0, n, 1);

      vector<int> b(n);
      auto conq = [&] (auto self, int l, int r, int p) -> void {
        t[p].resize(r - l);
        if (r - l == 1) {
          b[l] = t[p][0];
          return;
        }
        int m = (l + r) >> 1;
        tie(t[p << 1], t[p << 1 | 1]) = 
          make_pair(mul(t[p], t[p << 1 | 1]), mul(t[p], t[p << 1]));
        t[p] = Poly();
        self(self, l, m, p << 1);
        self(self, m, r, p << 1 | 1);
      };
      t[1] = mul(f, t[1].inv());
      conq(conq, 0, n, 1);

      return b;
    }

    vector<int> eval (const Poly &f, const vector<int> &a) {
      int n = f.size(), m = a.size();
      auto tf = f;
      auto ta = a;
      n = max(n, m);
      tf.resize(n);
      ta.resize(n);
      auto b = _eval(tf, ta, n);
      b.resize(m);
      return b;
    }
  }
}

using Math::Poly;

constexpr int P = 998244353;

IL constexpr int qpow (int b, int k = P - 2) {
  int r = 1;
  for (; k; k >>= 1, b = (LL)b * b % P) if (k & 1) r = (LL)r * b % P;
  return r;
}

constexpr int N = 2e5 + 9;
int n, m;

int fc[N << 2], ifc[N << 2];

void init (int Z) {
  fc[0] = 1;
  L (i, 1, Z) {
    fc[i] = (LL)fc[i - 1] * i % P;
  }
  ifc[Z] = qpow(fc[Z]);
  R (i, Z - 1, 0) {
    ifc[i] = (LL)ifc[i + 1] * (i + 1) % P;
  }
}

int C (int n, int m) {
  return n < m || m < 0 ? 0 : (LL)fc[n] * ifc[m] % P * ifc[n - m] % P;
}

int F (int n, int m) {
  return C(n + m, n);
}

int G (int n, int m) {
  return (F(n - 1, m - 1) * (LL)F(n - 1, m - 1) + (P - F(n - 2, m)) * (LL)F(n, m - 2)) % P;
}

int calc (int n) {
  return n < 0 ? 0 : (C(2 * n, n) + P - C(2 * n, n - 2)) % P;
}

Poly A, B;

int main () {
  ios::sync_with_stdio(0), cin.tie(0);
  cin >> n >> m;
  init((n + m) << 1);
  LL ns = 0;
  L (i, 0, n - 2) {
    A[i] = (LL)ifc[i] * ifc[i] % P;
  }
  L (i, 0, m - 2) {
    B[i] = (LL)ifc[i] * ifc[i] % P;
  }
  A *= B;
  L (i, 0, n + m - 4) {
    ns = (ns + 2LL * A[i] * fc[i] % P * fc[i]) % P;
  }
  A.redeg(n - 2);
  B.redeg(m - 2);
  L (i, 0, n - 2) {
    A[i] = i ? (LL)ifc[i - 1] * ifc[i + 1] % P : 0;
  }
  L (i, 0, m - 2) {
    B[i] = i ? (LL)ifc[i - 1] * ifc[i + 1] % P : 0;
  }
  A *= B;
  L (i, 2, n + m - 4) {
    ns = (ns + (P - 2LL) * A[i] % P * fc[i] % P * fc[i]) % P;
  }
  A.redeg(n - 1);
  B.redeg(m - 1);
  L (i, 0, n - 1) {
    A[i] = !!i;
  }
  L (i, 0, m - 1) {
    B[i] = !!i;
  }
  A *= A;
  B *= B;
  L (i, 2, 2 * n - 2) {
    ns = (ns + (LL)A[i] * G(n - i, m)) % P;
  }
  L (i, 2, 2 * m - 2) {
    ns = (ns + (LL)B[i] * G(n, m - i)) % P;
  }
  L (i, 1, n - 1) {
    ns = (ns + 2LL * G(n - i, m)) % P;
  }
  L (i, 1, m - 1) {
    ns = (ns + 2LL * G(n, m - i)) % P;
  }
  ns = (ns + G(n, m)) % P;
  cout << (ns + 2) % P << '\n';
}
// I love WHQ!