/**
 * @file qoj6411-1.cpp
 * @author n685
 * @brief
 * @date 2023-08-23
 *
 *
 */
#include <bits/stdc++.h>

#ifdef LOCAL
std::ifstream cin;
std::ofstream cout;
using std::cerr;
#else
using std::cin;
using std::cout;
#define cerr                                                                   \
  if (false)                                                                   \
  std::cerr
#endif

#ifdef LOCAL
#include "dd/debug.h"
#define dbg(...) lineInfo(__LINE__, #__VA_ARGS__), dbg1(__VA_ARGS__)
#define dbgR(...) lineInfo(__LINE__, #__VA_ARGS__), dbg2(__VA_ARGS__)
void nline() { cerr << '\n'; }
#else
#define dbg(...) 42
#define dbgR(...) 420
void nline() {}
#endif

template <class T> constexpr std::pair<T, T> exEucl(T a, T b) {
  if (a < b) {
    // auto [x, y] = exEucl(b, a);
    T x, y;
    std::tie(x, y) = exEucl(b, a);
    return {y, x};
  }
  if (b == 0) {
    assert(a == 1);
    return {1, 0};
  }
  // auto [x, y] = exEucl(b, a % b);
  T x, y;
  std::tie(x, y) = exEucl(b, a % b);
  return {y, x - (a / b) * y};
}
template <
    class T, class U,
    typename std::enable_if<std::is_integral<U>::value, bool>::type = true>
constexpr T binpow(const T &val, U b, T id = 1) {
  // 0^0 = 1
  T res = id, a = val;
  while (b > 0) {
    if (b % 2 == 1)
      res *= a;
    a *= a;
    b /= 2;
  }
  return res;
}

template <class Md, class V = int64_t> struct Mod {
  using T = typename std::decay<decltype(Md::value)>::type;
  T val = 0;

  template <class U> static constexpr T normalize(U val) {
    if (val <= -Md::value || Md::value <= val)
      val %= Md::value;
    if (val < 0)
      val += Md::value;
    return static_cast<T>(val);
  }

  constexpr Mod() : val(0) {}
  template <class U, typename std::enable_if<std::is_integral<U>::value,
                                             bool>::type = true>
  constexpr Mod(U _val) {
    val = normalize(_val);
  }

  // addition
  constexpr Mod &operator+=(Mod b) {
    val += b.val;
    if (val >= Md::value)
      val -= Md::value;
    return *this;
  }
  friend constexpr Mod operator+(Mod a, Mod b) { return (a += b); }
  constexpr Mod &operator++() { return (*this += 1); }
  constexpr Mod operator++(int) {
    Mod res = *this;
    ++(*this);
    return res;
  }

  // subtraction
  constexpr Mod &operator-=(Mod b) {
    val -= b.val;
    if (val < 0)
      val += Md::value;
    return *this;
  }
  friend constexpr Mod operator-(Mod a, Mod b) { return (a -= b); }
  constexpr Mod &operator--() { return (*this -= 1); }
  constexpr Mod operator--(int) {
    Mod res = *this;
    --(*this);
    return res;
  }

  // multiplication
  constexpr Mod &operator*=(Mod b) {
    val = static_cast<T>(static_cast<V>(val) * b.val % Md::value);
    return *this;
  }
  friend constexpr Mod operator*(Mod a, Mod b) { return (a *= b); }

  template <class U> constexpr Mod binpow(U b) const {
    return ::binpow(*this, b);
  }

  static constexpr T MXINV = (int)5e5;
  static Mod fac(int v) {
    static std::array<Mod, MXINV + 1> f;
    static bool init = false;
    if (!init) {
      f[0] = 1;
      for (int i = 1; i <= MXINV; ++i)
        f[i] = f[i - 1] * i;
      init = true;
    }
    return f[v];
  }
  static Mod ifac(int v) {
    static std::array<Mod, MXINV + 1> f;
    static bool init = false;
    if (!init) {
      f[MXINV] = fac(MXINV).largeInv();
      for (int i = MXINV - 1; i >= 0; --i)
        f[i] = f[i + 1] * (i + 1);
      init = true;
    }
    return f[v];
  }
  Mod smallInv() const {
    return ifac(static_cast<int>(val)) * fac(static_cast<int>(val) - 1);
  }
  Mod largeInv() const {
    return Mod(exEucl(static_cast<V>(val), static_cast<V>(Md::value)).first);
    // return binpow(Md::value - 2);
  }
  static Mod C(int n, int k) {
    if (n < 0 || k < 0 || n < k)
      return 0;
    return fac(n) * ifac(k) * ifac(n - k);
  }
  Mod inv() const {
    if (val <= MXINV)
      return smallInv();
    else
      return largeInv();
  }

  // comparison
  constexpr bool operator==(Mod b) const { return (val == b.val); }
  // constexpr auto operator<=>(const Mod &b) const = default;
  constexpr bool operator!=(Mod b) const { return (val != b.val); }
  constexpr bool operator<(Mod b) const { return (val < b.val); }
  constexpr bool operator>(Mod b) const { return (val > b.val); }
  constexpr bool operator<=(Mod b) const { return (val <= b.val); }
  constexpr bool operator>=(Mod b) const { return (val >= b.val); }

  // io
  friend std::istream &operator>>(std::istream &in, Mod &a) {
    V v;
    in >> v;
    a = Mod(v);
    return in;
  }
  friend std::ostream &operator<<(std::ostream &out, const Mod &a) {
    out << a.val;
    return out;
  }

  // conversion
  explicit constexpr operator T() const { return val; }
  constexpr const T &operator()() const { return val; }
  constexpr Mod operator-() const { return Mod(-val); }
};

constexpr int MOD = 998244353;
using Mint = Mod<std::integral_constant<std::decay<decltype(MOD)>::type, MOD>>;

std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
std::optional<Mint> sqrt(const Mint &n) {
  Mint c = 0;
  while ((c * c - n).binpow((MOD - 1) / 2) == 1)
    c = (int)rng() % MOD;
  if (c == 0)
    return std::nullopt;
  std::pair<Mint, Mint> res(1, 0), a(c, 1);
  int b = (MOD + 1) / 2;
  auto mul = [&c, &n](const std::pair<Mint, Mint> &u,
                      const std::pair<Mint, Mint> &v) -> std::pair<Mint, Mint> {
    return {u.first * v.first + u.second * v.second * (c * c - n),
            u.second * v.first + u.first * v.second};
  };
  while (b > 0) {
    if (b % 2 == 1)
      res = mul(res, a);
    a = mul(a, a);
    b /= 2;
  }
  return res.first;
  // return std::min(res.first, -res.first);
}

struct DFT {
  static constexpr int MX = 1 << 22;
  static constexpr Mint PRT = 5;
  static std::array<Mint, MX> omega;
  static bool init;

  std::vector<Mint> val;
  Mint rt(int k) { return omega[MX / (int)val.size() * k]; }
  DFT(std::vector<Mint> v, int s = -1) {
    if (v.empty())
      return;
    if (s == -1)
      s = (int)v.size();
    if (!init) {
      omega[0] = 1;
      Mint r = PRT.binpow((MOD - 1) / MX);
      for (int i = 1; i < MX; ++i)
        omega[i] = omega[i - 1] * r;
      init = true;
    }
    int m = s;
    int lg = std::__lg(2 * m - 1);
    m = (1 << lg);
    assert(m <= MX);
    v.resize(m);
    val.resize(m);
    for (int i = 0; i < m; ++i) {
      int rev = 0;
      for (int j = 0; j < lg; ++j)
        if ((1 << j) & i)
          rev += (1 << (lg - j - 1));
      val[rev] = v[i];
    }

    for (int sz = 2; sz <= m; sz *= 2) {
      for (int i = 0; i < m; i += sz) {
        for (int j = 0; j < sz / 2; ++j) {
          Mint u = val[i + j], vv = val[i + j + sz / 2] * rt(m / sz * j);
          val[i + j] = u + vv;
          val[i + j + sz / 2] = u - vv;
        }
      }
    }
  }
  std::vector<Mint> idft() {
    if (val.empty())
      return {};
    std::vector<Mint> res = DFT(val).val;
    std::reverse(res.begin() + 1, res.end());
    Mint i = Mint((int)res.size()).inv();
    for (Mint &j : res)
      j *= i;
    return res;
  }
  DFT operator*(const DFT &b) {
    DFT res(*this);
    res.val.resize(std::min(res.val.size(), b.val.size()));
    for (int i = 0; i < static_cast<int>(val.size()); ++i)
      res.val[i] *= b.val[i];
    return res;
  }
};
std::array<Mint, DFT::MX> DFT::omega;
bool DFT::init = false;

// https://cp-algorithms.com/algebra/polynomial.html
struct Poly {
  std::vector<Mint> val;

  Poly() {}
  explicit Poly(int d) : val(d + 1) {}
  Poly(const std::initializer_list<Mint> &i) : val(i) {}
  Poly(const std::vector<Mint> &v) : val(v) {}

  bool operator==(const Poly &b) const { return val == b.val; }
  bool operator!=(const Poly &b) const { return val != b.val; }
  int deg() const { return static_cast<int>(val.size()) - 1; }
  Mint &operator[](int ind) { return val[ind]; }
  const Mint &operator[](int ind) const { return val[ind]; }
  Mint lead() const { return val.back(); }
  Mint eval(Mint x) {
    Mint res = 0;
    for (int i = deg(); i >= 0; --i) {
      res *= x;
      res += val[i];
    }
    return res;
  }
  int trail() const {
    for (int i = 0; i <= deg(); ++i)
      if (val[i] != 0)
        return i;
    return deg() + 1;
  }
  void trim() {
    while (!val.empty() && val.back() == 0)
      val.pop_back();
  }
  void resize(int d) { val.resize(d + 1); }
  Poly mulxk(int k) const {
    Poly res(*this);
    res.val.insert(res.val.begin(), k, 0);
    return res;
  }
  Poly modxk(int k) const {
    if (k > deg())
      return *this;
    return std::vector<Mint>(val.begin(), val.begin() + k);
  }
  Poly divxk(int k) const {
    if (k > deg())
      return {0};
    return std::vector<Mint>(val.begin() + k, val.end());
  }
  Poly reverse(int d) const {
    auto res = val;
    res.resize(std::max((int)res.size(), d));
    return std::vector<Mint>(res.rbegin(), res.rbegin() + d);
  }
  Poly reverse() const { return reverse(deg() + 1); }
  bool isZero() const {
    for (int i = 0; i <= deg(); ++i)
      if (val[i] != 0)
        return false;
    return true;
  }
  Poly mulx(Mint x) const {
    Poly res(*this);
    Mint m = 1;
    for (int i = 1; i <= deg(); ++i)
      res[i] *= (m *= x);
    return res;
  }
  Poly x2() const {
    Poly res;
    for (int i = 0; i <= deg(); ++i) {
      res.val.push_back(val[i]);
      res.val.push_back(0);
    }
    return res;
  }
  // P(x) = P0(x^2) + xP1(x^2), returns P0(x) and P1(x)
  std::pair<Poly, Poly> bisect() const {
    Poly p0, p1;
    p0.val.reserve(deg() / 2 + 1);
    p1.val.reserve(deg() / 2 + 1);
    for (int i = 0; i <= deg(); ++i) {
      if (i % 2 == 0)
        p0.val.push_back(val[i]);
      else
        p1.val.push_back(val[i]);
    }
    return {p0, p1};
  }

  Poly &operator+=(const Poly &b) {
    val.resize(std::max(deg() + 1, b.deg() + 1));
    for (int i = 0; i <= b.deg(); ++i)
      val[i] += b.val[i];
    trim();
    return *this;
  }
  Poly operator+(const Poly &b) const { return Poly(*this) += b; }

  Poly &operator-=(const Poly &b) {
    val.resize(std::max(deg() + 1, b.deg() + 1));
    for (int i = 0; i <= b.deg(); ++i)
      val[i] -= b.val[i];
    trim();
    return *this;
  }
  Poly operator-(const Poly &b) const { return Poly(*this) -= b; }

  Poly operator-() const {
    Poly res(*this);
    for (int i = 0; i <= deg(); ++i)
      res[i] = -res[i];
    return res;
  }

  static constexpr int MI = 250;
  friend Poly slowMul(const Poly &a, const Poly &b) {
    if (a.isZero() || b.isZero())
      return {};
    Poly res(a.deg() + b.deg());
    for (int i = 0; i <= a.deg(); ++i) {
      for (int j = 0; j <= b.deg(); ++j) {
        res[i + j] += a[i] * b[j];
      }
    }
    res.trim();
    return res;
  }

  static int fftDeg(int v) {
    if (v == 0)
      return 0;
    return (1 << (std::__lg(v) + 1)) - 1;
  }

  friend Poly fastMul(const Poly &a, const Poly &b) {
    int sz = fftDeg(a.deg() + b.deg());
    Poly res = (DFT(a.val, sz + 1) * DFT(b.val, sz + 1)).idft();
    res.trim();
    return res;
  }
  friend Poly operator*(const Poly &a, const Poly &b) {
    if (std::min(a.deg(), b.deg()) < MI)
      return slowMul(a, b);
    else
      return fastMul(a, b);
  }
  Poly &operator*=(const Poly &b) { return *this = *this * b; }
  Poly &operator*=(const Mint &m) {
    for (int i = 0; i <= deg(); ++i)
      val[i] *= m;
    return *this;
  }
  friend Poly operator*(Poly a, Mint b) { return a *= b; }
  friend Poly operator*(Mint b, Poly a) { return a *= b; }

  Poly integr() const {
    Poly res(deg() + 1);
    for (int i = 0; i <= deg(); ++i)
      res[i + 1] = Mint(i + 1).inv() * val[i];
    return res;
  }
  Poly deriv() const {
    if (deg() == 0)
      return {};
    Poly res(deg() - 1);
    for (int i = 1; i <= deg(); ++i)
      res[i - 1] = i * val[i];
    return res;
  }

  Poly inv(int n) const {
    assert(val[0] != 0);
    auto Q = modxk(n);
    if (n == 1)
      return {Q[0].inv()};

    auto [q0, q1] = Q.mulx(-1).bisect();
    int sz = fftDeg(2 * ((n + 1) / 2 - 1));

    DFT q0f(q0.val, sz + 1), q1f(q1.val, sz + 1);
    DFT tf((Poly((q0f * q0f).idft()) - Poly((q1f * q1f).idft()).mulxk(1))
               .inv((n + 1) / 2)
               .val,
           sz + 1);

    return (Poly((q0f * tf).idft()).x2() +
            Poly((q1f * tf).idft()).x2().mulxk(1))
        .modxk(n);
  }

  std::pair<Poly, Poly> slowDiv(const Poly &b) const {
    Poly a(*this);
    Poly d;
    Mint ii = b.lead().inv();
    while (a.deg() >= b.deg()) {
      Mint c = a.lead() * ii;
      d.val.push_back(c);
      if (a.lead() != 0) {
        for (int i = 0; i <= b.deg(); ++i)
          a[a.deg() - i] -= c * b[b.deg() - i];
      }
      a.val.pop_back();
    }
    return {d.reverse(), a};
  }
  std::pair<Poly, Poly> fastDiv(const Poly &b) const {
    int rd = deg() - b.deg();
    Poly d = (reverse().modxk(rd + 1) * b.reverse().inv(rd + 1))
                 .modxk(rd + 1)
                 .reverse(rd + 1);
    return {d, *this - (b * d).modxk(deg() + 1)};
  }
  std::pair<Poly, Poly> div(const Poly &b) const {
    if (deg() < b.deg())
      return {{}, *this};
    else if (std::min(deg(), b.deg()) < MI)
      return slowDiv(b);
    else
      return fastDiv(b);
  }
  Poly operator/(const Poly &b) { return div(b).first; }
  Poly &operator/=(const Poly &b) { return *this = *this / b; }
  Poly operator%(const Poly &b) { return div(b).second; }
  Poly &operator%=(const Poly &b) { return *this = *this % b; }

  Poly ln(int n) const {
    assert(val[0] == 1);
    // Poly d = deriv();
    // d.resize(n - 1);
    return (deriv() * inv(n)).integr().modxk(n);
  }
  Poly exp(int n) const {
    if (isZero())
      return {1};
    assert(val[0] == 0);
    Poly res{1};
    for (int i = 1; i < n; i *= 2) {
      res = (res * (Poly{1} + modxk(2 * i) - res.ln(2 * i))).modxk(2 * i);
      // res -= res * (res.log(2 * i) - modxk(2 *)
    }
    return res.modxk(n);
  }

  template <class U> Poly binpow(U k, int n) {
    if (k == 0)
      return {1};
    else if (k == 1)
      return modxk(n);
    else if (k % 2 == 1)
      return (*this * pow(k - 1, n)).modxk(n);
    else {
      Poly res = pow(k / 2, n);
      return (res * res).modxk(n);
    }
  }
  template <class U> Poly pow(U k, int n) {
    trim();
    if (isZero())
      return {};
    if (k < MI)
      return binpow(k, n);
    else {
      if (val[0] == 1)
        return (Mint(k) * ln(n)).exp(n);
      int t = trail();
      if (t != 0 && (k >= n || k * t >= n))
        return {};
      return (divxk(t) * val[t].inv())
                 .pow(k, n - (int)(k * t))
                 .mulxk((int)(k * t))
                 .modxk(n) *
             val[t].binpow(k);
    }
  }
  std::optional<Poly> sqrt(int n) {
    trim();
    if (isZero())
      return Poly{};
    if (val[0] == 1)
      return (Mint(2).inv() * ln(n)).exp(n);
    int t = trail();
    std::optional<Mint> s = ::sqrt(val[t]);
    if (t % 2 == 1 || !s)
      return std::nullopt;
    auto res = (divxk(t) * val[t].inv()).sqrt(n - t / 2);
    return res ? res->mulxk(t / 2).modxk(n) * (*s) : res;
  }

  void eval(const std::vector<Poly> &t, const std::vector<Mint> &a,
            std::vector<Mint> &ans, int ind, int l, int r) {
    if (l >= (int)a.size())
      return;
    if (l == r) {
      ans[l] = eval(a[l]);
      return;
    }
    int mid = (l + r) / 2;
    (*this % t[2 * ind]).eval(t, a, ans, 2 * ind, l, mid);
    (*this % t[2 * ind + 1]).eval(t, a, ans, 2 * ind + 1, mid + 1, r);
  }
  std::vector<Mint> eval(const std::vector<Mint> &a) {
    if (isZero())
      return std::vector<Mint>((int)a.size(), 0);
    if ((int)a.size() == 1)
      return {eval(a[0])};
    int N = fftDeg((int)a.size() - 1) + 1;
    std::vector<Poly> t(2 * N, {1});
    for (int i = 0; i < (int)a.size(); ++i)
      t[i + N] = {-a[i], 1};
    for (int i = N - 1; i >= 1; --i)
      t[i] = t[2 * i] * t[2 * i + 1];

    std::vector<Mint> ans((int)a.size());
    eval(t, a, ans, 1, 0, N - 1);
    return ans;
  }
};

int main() {
#ifdef LOCAL
  cin.open("input.txt");
  cout.rdbuf()->pubsetbuf(0, 0);
  cout.open("output.txt");
#else
  cin.tie(nullptr)->sync_with_stdio(false);
#endif

  int n;
  cin >> n;

  std::vector<int> a(n + 2);
  for (int i = 1; i <= n; ++i)
    cin >> a[i];
  std::reverse(a.begin() + 1, a.end() - 1);

  int k = n;
  for (int i = 1; i <= n - 1; ++i)
    if (a[i] >= i && a[i + 1] < i + 1) {
      k = i;
      break;
    }

  Mint ans = 0;
  auto solve = [&]() {
    int t = a[k + 1];
    auto eval = [&](auto &self, int l, int r) -> Poly {
      if (l == r)
        return {a[l], -1};
      int mid = (l + r) / 2;
      return self(self, l, mid) * self(self, mid + 1, r);
    };
    Poly p = eval(eval, 1, k);
    std::vector<Mint> v(t + 1);
    std::iota(v.begin(), v.end(), 0);
    std::vector<Mint> val = p.eval(v);
    for (int i = 0; i <= t; ++i) {
      Mint mul = (i % 2 == 0) ? 1 : -1;
      ans += mul * Mint::C(t, i) * val[i];
    }
  };
  solve();
  std::vector<int> na(n + 2, n);
  for (int i = n; i > a[1]; --i)
    na[i] = 0;
  for (int i = 1; i <= n - 1; ++i) {
    for (int j = a[i]; j > a[i + 1]; --j)
      na[j] = i;
  }
  a.swap(na);
  a.back() = 0;
  solve();
  Mint f = 1;
  for (int i = 2; i <= k; ++i)
    f *= i;
  cout << k << ' ' << ans - f << '\n';
}