// clang-format off
#include <bits/stdc++.h>

using namespace std;

#if __cplusplus < 201400
  #warning "Please use c++14 or higher."
  #define INLINE_V
  #define REGISTER_V register
  #define CPP14CONSTEXPR
  #define gcd __gcd
  #define CPP14ENABLE_IF
#elif __cplusplus < 201700
  #define INLINE_V
  #define REGISTER_V
  #define CPP14CONSTEXPR constexpr
  #define gcd __gcd
  #define CPP14ENABLE_IF ,enable_if_t<_is_integer<T>, int> = 0
#else
  #define INLINE_V inline
  #define REGISTER_V
  #define CPP14CONSTEXPR constexpr
  #define CPP14ENABLE_IF ,enable_if_t<_is_integer<T>, int> = 0
#endif

#if !defined(_WIN32) && !defined(LOCK_GETCHAR)
  #define getchar getchar_unlocked
#endif

#define il inline
#define mkp make_pair
#define fi first
#define se second
#define For(i,j,k) for(REGISTER_V decltype(k-j) i=(j);i<=(k);++i) // NOLINT
#define ForDown(i,j,k) for(REGISTER_V decltype(k-j) i=(j);i>=(k);--i) // NOLINT
#define pb push_back
#define eb emplace_back
#ifndef ONLINE_JUDGE
#define FileIO(filename) freopen(filename".in","r",stdin);freopen(filename".out","w",stdout)
#else
#define FileIO(filename)
#endif

using ll = long long;
// using lll = __int128_t;
using uint = unsigned int;
using ull = unsigned long long;
// using ulll = __uint128_t;
using db = double;
using ldb = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;

#if __cplusplus >= 201400
  template <class T> INLINE_V constexpr bool _is_integer = numeric_limits<T>::is_integer;
  // template <> INLINE_V constexpr bool _is_integer<__int128> = true;
  // template <> INLINE_V constexpr bool _is_integer<__uint128_t> = true;
  template <> INLINE_V constexpr bool _is_integer<bool> = false;
  template <> INLINE_V constexpr bool _is_integer<char> = false;
  template <class T CPP14ENABLE_IF>
    INLINE_V constexpr T INF = numeric_limits<T>::max() >> 1;
#endif

template<typename T> constexpr il T sq(const T & x){return x*x;}
template<typename T> CPP14CONSTEXPR il void cmin(T & x, const T &y){x=min(x,y);}
template<typename T> CPP14CONSTEXPR il void cmax(T & x, const T &y){x=max(x,y);}
template<typename T> CPP14CONSTEXPR il T qpow(T x, ull y, T mod){T ans=1;x%=mod;while(y){if(y&1)(ans*=x)%=mod;(x*=x)%=mod;y>>=1;}return ans;}
template<typename T> CPP14CONSTEXPR il T qpow(T x, ull y){T ans=1;while(y){if(y&1)ans*=x;x*=x;y>>=1;}return ans;}
template<typename T CPP14ENABLE_IF> il void read(T &x){ x=0;int f=1;int c=getchar();while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}while(isdigit(c)){x=x*10+c-'0';c=getchar();}x*=f;}
template<typename T, typename ... Args> il void read(T &x, Args &... y){ read(x);read(y...); }

// File head end
// clang-format on

namespace Modint {
template <const uint Mod> class Modint {
  uint _val;
  il static unordered_map<uint, uint> _inv;

public:
  Modint() : _val(0) {}
  constexpr Modint(ll val) : _val((val % Mod + Mod) % Mod) {}
  [[nodiscard]] il uint value() const { return _val; }
  [[nodiscard]] il uint safe_value() const { return (_val + Mod) % Mod; }
  [[nodiscard]] il uint inv() const {
    return _inv.count(_val) ? _inv[_val]
                            : _inv[_val] = qpow(*this, Mod - 2)._val;
  }
  Modint operator-() const { return (Mod - this->safe_value()) % Mod; }
  void operator*=(const Modint &rhs) { _val = ((ull)_val * rhs._val) % Mod; }
  void operator/=(const Modint &rhs) { _val = ((ull)_val * rhs.inv()) % Mod; }
  void operator+=(const Modint &rhs) {
    int(_val += rhs._val - (Mod << 1)) < 0 ? _val += (Mod << 1) : (ull){};
  }
  void operator-=(const Modint &rhs) {
    int(_val -= rhs._val) < 0 ? _val += (Mod << 1) : (ull){};
  }
#define setOper(x)                                                             \
  [[nodiscard]] Modint operator x(const Modint &rhs) const {                   \
    auto lhs = *this;                                                          \
    lhs x## = rhs;                                                             \
    return lhs;                                                                \
  }
  setOper(+) setOper(-) setOper(*) setOper(/)
#undef setOper
};
template <const ll Mod> istream &operator>>(istream &istr, Modint<Mod> &x) {
  ll _temp;
  istr >> _temp, x = _temp;
  return istr;
}
template <const ll Mod> ostream &operator<<(ostream &ostr, Modint<Mod> x) {
  ostr << x.value();
  return ostr;
}
} // namespace Modint

using Z = Modint::Modint<998244353>;
constexpr Z operator""_Z(ull x);

class Poly : public vector<Z> {
  il static constexpr Z G = 3;
  il static constexpr uint MAXN = 1u << 21;

  il static vector<uint> _Rev;
  il static uint cur_len = 0;
  il static bool gn_table_ok = 0;
  il static Z GN[MAXN];
  il static void init_rev(uint len) {
    cur_len = len;
    _Rev.resize(len);
    For(i, 0, len - 1) {
      _Rev[i] = _Rev[i >> 1] >> 1;
      if (i & 1)
        _Rev[i] |= len >> 1;
    }
  }
  il static void init_gn_table() {
    GN[21] = qpow(G, 998244352 / (1 << 21));
    for (uint l = MAXN >> 1, i = 20; l >= 2; l >>= 1, i--) {
      GN[i] = sq(GN[i + 1]);
    }
    gn_table_ok = 1;
  }

  il void NTT(uint len, bool tp, Poly &res) const {
    res = *this;
    res.resize(len);
    if (len != cur_len)
      init_rev(len);
    if (!gn_table_ok)
      init_gn_table();
    for (uint i = 0; i < len; i++)
      if (i < _Rev[i])
        ::swap(res[i], res[_Rev[i]]);
    for (uint l = 2, lg = 1; l <= len; l <<= 1, lg++) {
      uint m = l >> 1;
      Z gn = GN[lg];
      for (uint i = 0; i < len; i += l) {
        Z g = 1;
        for (uint j = 0; j < m; j++, g *= gn) {
          Z tmp = res[i + j + m] * g;
          res[i + j + m] = res[i + j] - tmp;
          res[i + j] += tmp;
        }
      }
    }
    if (!tp) {
      reverse(res.begin() + 1, res.begin() + len);
      auto inv = Z(len).inv();
      For(i, 0, len - 1) res[i] *= inv;
    }
  }

public:
  Poly() = default;
  Poly(int sz) { this->clear(), this->resize(sz); }
  void operator+=(const Poly &rhs) {
    int n_sz = max(this->size(), rhs.size()), rhs_sz = rhs.size(); // NOLINT
    this->resize(n_sz);
    For(i, 0, rhs_sz - 1) this->operator[](i) += rhs[i];
  }
  void operator-=(const Poly &rhs) {
    int n_sz = max(this->size(), rhs.size()), rhs_sz = rhs.size(); // NOLINT
    this->resize(n_sz);
    For(i, 0, rhs_sz - 1) operator[](i) -= rhs[i];
  }
  void operator*=(const Poly &rhs) {
    int N = 1, NN = this->size() + rhs.size() - 1; // NOLINT
    while (N < NN)
      N <<= 1;
    Poly x, y, ans{N};
    this->NTT(N, 1, x), rhs.NTT(N, 1, y);
    For(i, 0, N - 1) ans[i] = x[i] * y[i];
    ans.NTT(N, 0, *this);
    resize(NN);
  }
#define setOper(x)                                                             \
  [[nodiscard]] Poly operator x(const Poly &rhs) const {                       \
    auto lhs = *this;                                                          \
    lhs x## = rhs;                                                             \
    return lhs;                                                                \
  }
  setOper(+) setOper(-) setOper(*)
#undef setOper
};

namespace {
constexpr ll MAXN = 1e5 + 5, mod = 998244353;

int T, m, a, b, c, d;
ll L, R;

Poly _qpow(Poly x, ull y) {
  Poly ans(1);
  ans[0] = 1;
  while (y) {
    if (y & 1) {
      ans *= x;
      for (int i = m; i < ans.size(); i++)
        ans[i % m] += ans[i];
      ans.resize(m);
    }
    y >>= 1, x *= x;
    for (int i = m; i < x.size(); i++)
      x[i % m] += x[i];
    x.resize(m);
  }
  // For(i, 1, y) ans *= x;
  // for (int i = m; i < ans.size(); i++)
  //   ans[i % m] += ans[i];
  ans.resize(m);
  return ans;
}

il void solve() {
  read(m, a, b, c, d);
  L = (!a || !b) ? 1 : __gcd(qpow(1ll * m, a) - 1, qpow(1ll * m, b) - 1) + 2;
  R = (!c || !d) ? 0 : __gcd(qpow(1ll * m, c) - 1, qpow(1ll * m, d) - 1) + 1;
  // cerr << L << ' ' << R << '\n';
  array<Poly, 2> f;
  f[0].resize(m), f[1].resize(m);
  if (L / m == R / m) {
    f[1][0] = 1;
    For(i, L, R) {
      int cur = (i - L) & 1, pre = cur ^ 1;
      f[cur] = f[pre];
      For(j, 0, m - 1) f[cur][(j + i) % m] += f[pre][j];
    }
    cout << f[R - L & 1][0].safe_value() << '\n';
    return;
  }
  f[1][0] = 1;
  For(i, 0, m - 1) {
    int cur = i & 1, pre = cur ^ 1;
    f[cur] = f[pre];
    For(j, 0, m - 1) f[cur][(j + i) % m] += f[pre][j];
    if (L == 4 && R == 16) {
      for (auto x : f[cur])
        cerr << x.safe_value() << ' ';
      cerr << '\n';
    }
  }
  if (L == 4 && R == 16) {
    auto g = _qpow(f[m - 1 & 1], 3);
    for (auto x : g)
      cerr << x.safe_value() << ' ';
    cerr << '\n';
  }
  auto g = _qpow(f[m - 1 & 1], R / m - L / m - 1);
  assert(g.size() == m);
  f[1].swap(g);
  ll id = (R / m) * m;
  For(i, id, R) {
    int cur = (i - id) & 1, pre = cur ^ 1;
    f[cur] = f[pre];
    For(j, 0, m - 1) { f[cur][(j + i) % m] += f[pre][j]; }
  }
  if (!(R - id & 1))
    f[1].swap(f[0]);
  id = (L / m + 1) * m - 1;
  For(i, L, id) {
    int cur = (i - L) & 1, pre = cur ^ 1;
    f[cur] = f[pre];
    For(j, 0, m - 1) f[cur][(j + i) % m] += f[pre][j];
  }
  cout << f[id - L & 1][0].safe_value() << '\n';
}
il void solver_main() {
  read(T);
  while (T--)
    solve();
}
} // namespace

signed main() { return solver_main(), 0; }