#include <algorithm>
#include <cassert>
#include <cstring>
#include <iostream>
#include <vector>

#define TRACE(x) std::cout << #x << " = " << x << "\n"
#define _ << " _ " <<

using namespace std;
template <int32_t P>
struct ModInt_t {
  int32_t value;

  static_assert(P < (1 << 30) - 1, "2xP must fit into 32-bit signed integer");

  ModInt_t() : value{0} {};

  constexpr explicit ModInt_t(int32_t v) : value(v) {
    if (value >= P || value <= -P) value %= P;
    if (value < 0) value += P;
  };

  constexpr explicit ModInt_t(int64_t v) {
    v %= P;
    if (v < 0) v += P;
    value = v;
  };

  explicit operator bool() const { return value != 0; }
  explicit operator int32_t() const { return value; }

  ModInt_t& operator+=(const ModInt_t& other) {
    value += other.value;
    if (value >= P) value -= P;
    return *this;
  }

  ModInt_t& operator-=(const ModInt_t& other) {
    value -= other.value;
    if (value < 0) value += P;
    return *this;
  }

  ModInt_t& operator*=(const ModInt_t& other) {
    int64_t result = static_cast<int64_t>(value) * other.value;
    value = static_cast<int32_t>(result % P);
    return *this;
  }

  static ModInt_t inverse(ModInt_t x) { return ModInt_t{inverse(x.value)}; }

 private:
  static int32_t inverse(int32_t a) {
    int32_t b = P, x = 1, y = 0;
    while (b != 0) {
      auto k = a / b;
      a -= k * b;
      std::swap(a, b);
      x -= k * y;
      std::swap(x, y);
    }
    assert(a == 1);
    if (x < 0) x += P;
    return x;
  }
};

template <int32_t P>
ModInt_t<P> operator+(const ModInt_t<P>& a, const ModInt_t<P>& b) {
  auto res = a;
  return res += b;
};

template <int32_t P>
ModInt_t<P> operator-(const ModInt_t<P>& a, const ModInt_t<P>& b) {
  auto res = a;
  return res -= b;
};

template <int32_t P>
ModInt_t<P> operator*(const ModInt_t<P>& a, const ModInt_t<P>& b) {
  auto res = a;
  return res *= b;
};

template <int32_t P>
bool operator==(const ModInt_t<P>& a, const ModInt_t<P>& b) {
  return a.value == b.value;
};

template <int32_t P>
std::ostream& operator<<(std::ostream& os, const ModInt_t<P>& a) {
  os << a.value;
  return os;
}

template <typename T>
struct MulMonoid {
  using value_type = T;
  constexpr static T identity() { return T{1}; }
  constexpr static T op(const T& a, const T& b) { return a * b; }
};

template <typename T, typename U, typename Monoid = MulMonoid<T>>
T power(T a, U n) {
  T r{Monoid::identity()};
  while (n > 0) {
    if (n % 2) r = Monoid::op(r, a);
    a = Monoid::op(a, a);
    n /= 2;
  }
  return r;
}

using ModInt = ModInt_t<998244353>;

const int MAX = 3030;

ModInt f[MAX][MAX];
ModInt g[MAX][MAX];
ModInt h[MAX][MAX];
ModInt pw[MAX][MAX];
ModInt ipw[MAX][MAX];

int main() {
  std::ios_base::sync_with_stdio(false);
  int A, B, C, D;
  cin >> A >> B >> C >> D;

  for (int i = 1; i < MAX; ++i) {
    pw[i][0] = ModInt{1};
    ipw[i][0] = ModInt{1};
    auto ii = ModInt::inverse(ModInt{i});
    for (int j = 1; j < MAX; ++j) {
      pw[i][j] = pw[i][j - 1] * ModInt{i};
      ipw[i][j] = ipw[i][j - 1] * ii;
    }
  }

  f[A][B] = ModInt{1};
  for (int r = A; r <= C; ++r) {
    for (int c = B; c <= D; ++c) {
      g[r][c] += g[r - 1][c];
      f[r][c] += g[r][c] * pw[c - 1][r];

      h[r][c] += h[r][c - 1];
      f[r][c] += h[r][c] * pw[r - 1][c];

      if (r == C) {
        f[r][c + 1] += f[r][c] * ModInt{r};
      }
      if (c == D) {
        f[r + 1][c] += f[r][c] * ModInt{c};
      }

      f[r + 1][c + 1] += f[r][c] * ModInt{r} * ModInt{c};
      g[r + 1][c + 1] += f[r][c] * ipw[c][r];
      h[r + 1][c + 1] += f[r][c] * ipw[r][c];
    }
  }

  cout << f[C][D] << "\n";
  return 0;
}


Measured memory_bytes: 182964