Problem p02616 (C++) — buggy submission, verdict: Runtime Error

#pragma region kyopro_template
#include <bits/stdc++.h>
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define each(x, v) for (auto &x : v)
#define all(v) (v).begin(), (v).end()
#define sz(v) ((int)(v).size())
#define mem(a, val) memset(a, val, sizeof(a))
#define ini(...)                                                               \\
  int __VA_ARGS__;                                                             \\
  in(__VA_ARGS__)
#define inl(...)                                                               \\
  long long __VA_ARGS__;                                                       \\
  in(__VA_ARGS__)
#define ins(...)                                                               \\
  string __VA_ARGS__;                                                          \\
  in(__VA_ARGS__)
#define inc(...)                                                               \\
  char __VA_ARGS__;                                                            \\
  in(__VA_ARGS__)
#define in2(s, t)                                                              \\
  for (int i = 0; i < (int)s.size(); i++) {                                    \\
    in(s[i], t[i]);                                                            \\
  }
#define in3(s, t, u)                                                           \\
  for (int i = 0; i < (int)s.size(); i++) {                                    \\
    in(s[i], t[i], u[i]);                                                      \\
  }
#define in4(s, t, u, v)                                                        \\
  for (int i = 0; i < (int)s.size(); i++) {                                    \\
    in(s[i], t[i], u[i], v[i]);                                                \\
  }
#define rep(i, N) for (long long i = 0; i < (long long)(N); i++)
#define repr(i, N) for (long long i = (long long)(N)-1; i >= 0; i--)
#define rep1(i, N) for (long long i = 1; i <= (long long)(N); i++)
#define repr1(i, N) for (long long i = (N); (long long)(i) > 0; i--)
using namespace std;
void solve();
using ll = long long;
template <class ll = ll> using V = vector<ll>;
using vi = vector<int>;
using vl = vector<long long>;
using vvi = vector<vector<int>>;
using vd = V<double>;
using vs = V<string>;
using vvl = vector<vector<long long>>;
using P = pair<long long, long long>;
using vp = vector<P>;
using pii = pair<int, int>;
using vpi = vector<pair<int, int>>;
constexpr int inf = 1001001001;
constexpr long long infLL = (1LL << 61) - 1;
template <typename ll, typename U> inline bool amin(ll &x, U y) {
  return (y < x) ? (x = y, true) : false;
}
template <typename ll, typename U> inline bool amax(ll &x, U y) {
  return (x < y) ? (x = y, true) : false;
}
template <typename ll, typename U> ll ceil(ll a, U b) {
  return (a + b - 1) / b;
}
constexpr ll TEN(int n) {
  ll ret = 1, x = 10;
  while (n) {
    if (n & 1)
      ret *= x;
    x *= x;
    n >>= 1;
  }
  return ret;
}

template <typename ll, typename U>
ostream &operator<<(ostream &os, const pair<ll, U> &p) {
  os << p.first << " " << p.second;
  return os;
}
template <typename ll, typename U>
istream &operator>>(istream &is, pair<ll, U> &p) {
  is >> p.first >> p.second;
  return is;
}
template <typename ll> ostream &operator<<(ostream &os, const vector<ll> &v) {
  int s = (int)v.size();
  for (int i = 0; i < s; i++)
    os << (i ? " " : "") << v[i];
  return os;
}
template <typename ll> istream &operator>>(istream &is, vector<ll> &v) {
  for (auto &x : v)
    is >> x;
  return is;
}
void in() {}
template <typename ll, class... U> void in(ll &t, U &...u) {
  cin >> t;
  in(u...);
}
void out() { cout << "\\n"; }
template <typename ll, class... U> void out(const ll &t, const U &...u) {
  cout << t;
  if (sizeof...(u))
    cout << " ";
  out(u...);
}
template <typename ll> void die(ll x) {
  out(x);
  exit(0);
}

#ifdef NyaanDebug
#include "NyaanDebug.h"
#define trc(...)                                                               \\
  do {                                                                         \\
    cerr << #__VA_ARGS__ << " = ";                                             \\
    dbg_out(__VA_ARGS__);                                                      \\
  } while (0)
#define trca(v, N)                                                             \\
  do {                                                                         \\
    cerr << #v << " = ";                                                       \\
    array_out(v, N);                                                           \\
  } while (0)
#define trcc(v)                                                                \\
  do {                                                                         \\
    cerr << #v << " = {";                                                      \\
    each(x, v) { cerr << " " << x << ","; }                                    \\
    cerr << "}" << endl;                                                       \\
  } while (0)
#else
#define trc(...)
#define trca(...)
#define trcc(...)
int main() { solve(); }
#endif

struct IoSetupNya {
  IoSetupNya() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    cerr << fixed << setprecision(7);
  }
} iosetupnya;

inline int popcnt(unsigned long long a) { return __builtin_popcountll(a); }
inline int lsb(unsigned long long a) { return __builtin_ctzll(a); }
inline int msb(unsigned long long a) { return 63 - __builtin_clzll(a); }
template <typename ll> inline int getbit(ll a, int i) { return (a >> i) & 1; }
template <typename ll> inline void setbit(ll &a, int i) { a |= (1LL << i); }
template <typename ll> inline void delbit(ll &a, int i) { a &= ~(1LL << i); }
template <typename ll> int lb(const vector<ll> &v, const ll &a) {
  return lower_bound(begin(v), end(v), a) - begin(v);
}
template <typename ll> int ub(const vector<ll> &v, const ll &a) {
  return upper_bound(begin(v), end(v), a) - begin(v);
}
template <typename ll> vector<ll> mkrui(const vector<ll> &v) {
  vector<ll> ret(v.size() + 1);
  for (int i = 0; i < int(v.size()); i++)
    ret[i + 1] = ret[i] + v[i];
  return ret;
};
template <typename ll> vector<ll> mkuni(const vector<ll> &v) {
  vector<ll> ret(v);
  sort(ret.begin(), ret.end());
  ret.erase(unique(ret.begin(), ret.end()), ret.end());
  return ret;
}
template <typename F> vector<int> mkord(int N, F f) {
  vector<int> ord(N);
  iota(begin(ord), end(ord), 0);
  sort(begin(ord), end(ord), f);
  return ord;
}
template <typename ll = int> vector<ll> mkiota(int N) {
  vector<ll> ret(N);
  iota(begin(ret), end(ret), 0);
  return ret;
}
static constexpr uint32_t get_r(int mod) {
  uint64_t ret = 1, m = mod, n = mod - 2;
  while (n) {
    ret = uint32_t(ret * m);
    m = uint32_t(m * m);
    n >>= 1;
  }
  return ret;
};

template <int mod> struct ModInt {
  int x;

  ModInt() : x(0) {}

  ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}

  ModInt &operator+=(const ModInt &p) {
    if ((x += p.x) >= mod)
      x -= mod;
    return *this;
  }

  ModInt &operator-=(const ModInt &p) {
    if ((x += mod - p.x) >= mod)
      x -= mod;
    return *this;
  }

  ModInt &operator*=(const ModInt &p) {
    x = (int)(1LL * x * p.x % mod);
    return *this;
  }

  ModInt &operator/=(const ModInt &p) {
    *this *= p.inverse();
    return *this;
  }

  ModInt operator-() const { return ModInt(-x); }

  ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }

  ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }

  ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }

  ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }

  bool operator==(const ModInt &p) const { return x == p.x; }

  bool operator!=(const ModInt &p) const { return x != p.x; }

  ModInt inverse() const {
    int a = x, b = mod, u = 1, v = 0, t;
    while (b > 0) {
      t = a / b;
      swap(a -= t * b, b);
      swap(u -= t * v, v);
    }
    return ModInt(u);
  }

  ModInt pow(int64_t n) const {
    ModInt ret(1), mul(x);
    while (n > 0) {
      if (n & 1)
        ret *= mul;
      mul *= mul;
      n >>= 1;
    }
    return ret;
  }

  friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }

  friend istream &operator>>(istream &is, ModInt &a) {
    int64_t t;
    is >> t;
    a = ModInt<mod>(t);
    return (is);
  }

  static constexpr int get_mod() { return mod; }
};

#pragma endregion

constexpr int MOD = /** 998244353;  //*/ 1000000007;
using mint = ModInt<MOD>;
using vm = vector<mint>;

template <typename T> struct edge {
  int src, to;
  T cost;

  edge(int to, T cost) : src(-1), to(to), cost(cost) {}
  edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}

  edge &operator=(const int &x) {
    to = x;
    return *this;
  }

  operator int() const { return to; }
};
template <typename T> using Edges = vector<edge<T>>;
template <typename T> using WeightedGraph = vector<Edges<T>>;
using UnweightedGraph = vector<vector<int>>;

// Input of (Unweighted) Graph
UnweightedGraph graph(int N, int M = -1, bool is_directed = false,
                      bool is_1origin = true) {
  UnweightedGraph g(N);
  if (M == -1)
    M = N - 1;
  for (int _ = 0; _ < M; _++) {
    int x, y;
    cin >> x >> y;
    if (is_1origin)
      x--, y--;
    g[x].pb(y);
    if (!is_directed)
      g[y].pb(x);
  }
  return g;
}

// Input of Weighted Graph
template <typename T>
WeightedGraph<T> wgraph(int N, int M = -1, bool is_directed = false,
                        bool is_1origin = true) {
  WeightedGraph<T> g(N);
  if (M == -1)
    M = N - 1;
  for (int _ = 0; _ < M; _++) {
    int x, y;
    cin >> x >> y;
    T c;
    cin >> c;
    if (is_1origin)
      x--, y--;
    g[x].eb(x, y, c);
    if (!is_directed)
      g[y].eb(y, x, c);
  }
  return g;
}

// Depth of Rooted Tree
// unvisited nodes : d = -1
vector<int> Depth(UnweightedGraph &g, int start = 0) {
  vector<int> d(g.size(), -1);
  auto dfs = [&](auto rec, int cur, int par = -1) -> void {
    d[cur] = par == -1 ? 0 : d[par] + 1;
    each(dst, g[cur]) {
      if (dst == par)
        continue;
      rec(rec, dst, cur);
    }
  };
  dfs(dfs, start);
  return d;
}

// Diameter of Tree
pair<int, int> Diameter(UnweightedGraph &g, int start = 0) {
  auto d = Depth(g, start);
  int u = max_element(begin(d), end(d)) - begin(d);
  d = Depth(g, u);
  int v = max_element(begin(d), end(d)) - begin(d);
  return make_pair(u, v);
}

void solve() {
  ini(N, K);
  vl a(N);
  in(a);
  if (N == K) {
    ll ans = 1;
    each(x, a) ans = ans * x % MOD;
    if (ans < 0)
      ans += MOD;
    die(ans);
  }

  vl p, m;
  each(x, a) {
    if (x > 0)
      p.push_back(x);
    else if (x < 0)
      m.push_back(x);
  }

  if (sz(p) + sz(m) < K)
    die(0);
  if (sz(p) + sz(m) == K) {
    if (sz(m) % 2 == 1)
      die(0);
    ll ans = 1;
    each(x, p) ans = ans * x % MOD;
    each(x, m) ans = ans * x % MOD;
    if (ans < 0)
      ans += MOD;
    die(ans);
  }

  sort(all(p), greater<>());
  sort(all(m));

  // 余剰がある->全部マイナスでない限り耐え
  if (sz(p) == 0) {
    if (K % 2 == 0) {
      ll ans = 1;
      rep(i, K) ans = ans * m[i] % MOD;
      if (ans < 0)
        ans += MOD;
      die(ans);
    } else if (sz(m) != N) {
      die(0);
    } else {
      reverse(all(m));
      ll ans = 1;
      rep(i, K) ans = ans * m[i] % MOD;
      if (ans < 0)
        ans += MOD;
      die(ans);
    }
  }

  int pi = min(K, sz(p));
  int mi = K - pi;
  if (mi % 2 == 1)
    mi++, pi--;
  while (1) {
    if (mi + 2 > sz(m))
      break;
    if (pi < 2)
      break;
    if (m[mi] * m[mi + 1] <= p[pi - 1] * p[pi - 2])
      break;
    pi -= 2;
    mi += 2;
  }
  trc(pi, mi);
  ll ans = 1;
  rep(i, pi) ans = ans * p[i] % MOD;
  rep(i, mi) ans = ans * m[i] % MOD;
  if (ans < 0)
    ans += MOD;
  die(ans);
}

Error: 1

Fixed submission:

#pragma region kyopro_template
#include <bits/stdc++.h>
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define each(x, v) for (auto &x : v)
#define all(v) (v).begin(), (v).end()
#define sz(v) ((int)(v).size())
#define mem(a, val) memset(a, val, sizeof(a))
#define ini(...)                                                               \\
  int __VA_ARGS__;                                                             \\
  in(__VA_ARGS__)
#define inl(...)                                                               \\
  long long __VA_ARGS__;                                                       \\
  in(__VA_ARGS__)
#define ins(...)                                                               \\
  string __VA_ARGS__;                                                          \\
  in(__VA_ARGS__)
#define inc(...)                                                               \\
  char __VA_ARGS__;                                                            \\
  in(__VA_ARGS__)
#define in2(s, t)                                                              \\
  for (int i = 0; i < (int)s.size(); i++) {                                    \\
    in(s[i], t[i]);                                                            \\
  }
#define in3(s, t, u)                                                           \\
  for (int i = 0; i < (int)s.size(); i++) {                                    \\
    in(s[i], t[i], u[i]);                                                      \\
  }
#define in4(s, t, u, v)                                                        \\
  for (int i = 0; i < (int)s.size(); i++) {                                    \\
    in(s[i], t[i], u[i], v[i]);                                                \\
  }
#define rep(i, N) for (long long i = 0; i < (long long)(N); i++)
#define repr(i, N) for (long long i = (long long)(N)-1; i >= 0; i--)
#define rep1(i, N) for (long long i = 1; i <= (long long)(N); i++)
#define repr1(i, N) for (long long i = (N); (long long)(i) > 0; i--)
using namespace std;
void solve();
using ll = long long;
template <class ll = ll> using V = vector<ll>;
using vi = vector<int>;
using vl = vector<long long>;
using vvi = vector<vector<int>>;
using vd = V<double>;
using vs = V<string>;
using vvl = vector<vector<long long>>;
using P = pair<long long, long long>;
using vp = vector<P>;
using pii = pair<int, int>;
using vpi = vector<pair<int, int>>;
constexpr int inf = 1001001001;
constexpr long long infLL = (1LL << 61) - 1;
template <typename ll, typename U> inline bool amin(ll &x, U y) {
  return (y < x) ? (x = y, true) : false;
}
template <typename ll, typename U> inline bool amax(ll &x, U y) {
  return (x < y) ? (x = y, true) : false;
}
template <typename ll, typename U> ll ceil(ll a, U b) {
  return (a + b - 1) / b;
}
constexpr ll TEN(int n) {
  ll ret = 1, x = 10;
  while (n) {
    if (n & 1)
      ret *= x;
    x *= x;
    n >>= 1;
  }
  return ret;
}

template <typename ll, typename U>
ostream &operator<<(ostream &os, const pair<ll, U> &p) {
  os << p.first << " " << p.second;
  return os;
}
template <typename ll, typename U>
istream &operator>>(istream &is, pair<ll, U> &p) {
  is >> p.first >> p.second;
  return is;
}
template <typename ll> ostream &operator<<(ostream &os, const vector<ll> &v) {
  int s = (int)v.size();
  for (int i = 0; i < s; i++)
    os << (i ? " " : "") << v[i];
  return os;
}
template <typename ll> istream &operator>>(istream &is, vector<ll> &v) {
  for (auto &x : v)
    is >> x;
  return is;
}
void in() {}
template <typename ll, class... U> void in(ll &t, U &...u) {
  cin >> t;
  in(u...);
}
void out() { cout << "\\n"; }
template <typename ll, class... U> void out(const ll &t, const U &...u) {
  cout << t;
  if (sizeof...(u))
    cout << " ";
  out(u...);
}
template <typename ll> void die(ll x) {
  out(x);
  exit(0);
}

#ifdef NyaanDebug
#include "NyaanDebug.h"
#define trc(...)                                                               \\
  do {                                                                         \\
    cerr << #__VA_ARGS__ << " = ";                                             \\
    dbg_out(__VA_ARGS__);                                                      \\
  } while (0)
#define trca(v, N)                                                             \\
  do {                                                                         \\
    cerr << #v << " = ";                                                       \\
    array_out(v, N);                                                           \\
  } while (0)
#define trcc(v)                                                                \\
  do {                                                                         \\
    cerr << #v << " = {";                                                      \\
    each(x, v) { cerr << " " << x << ","; }                                    \\
    cerr << "}" << endl;                                                       \\
  } while (0)
#else
#define trc(...)
#define trca(...)
#define trcc(...)
int main() { solve(); }
#endif

struct IoSetupNya {
  IoSetupNya() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    cerr << fixed << setprecision(7);
  }
} iosetupnya;

inline int popcnt(unsigned long long a) { return __builtin_popcountll(a); }
inline int lsb(unsigned long long a) { return __builtin_ctzll(a); }
inline int msb(unsigned long long a) { return 63 - __builtin_clzll(a); }
template <typename ll> inline int getbit(ll a, int i) { return (a >> i) & 1; }
template <typename ll> inline void setbit(ll &a, int i) { a |= (1LL << i); }
template <typename ll> inline void delbit(ll &a, int i) { a &= ~(1LL << i); }
template <typename ll> int lb(const vector<ll> &v, const ll &a) {
  return lower_bound(begin(v), end(v), a) - begin(v);
}
template <typename ll> int ub(const vector<ll> &v, const ll &a) {
  return upper_bound(begin(v), end(v), a) - begin(v);
}
template <typename ll> vector<ll> mkrui(const vector<ll> &v) {
  vector<ll> ret(v.size() + 1);
  for (int i = 0; i < int(v.size()); i++)
    ret[i + 1] = ret[i] + v[i];
  return ret;
};
template <typename ll> vector<ll> mkuni(const vector<ll> &v) {
  vector<ll> ret(v);
  sort(ret.begin(), ret.end());
  ret.erase(unique(ret.begin(), ret.end()), ret.end());
  return ret;
}
template <typename F> vector<int> mkord(int N, F f) {
  vector<int> ord(N);
  iota(begin(ord), end(ord), 0);
  sort(begin(ord), end(ord), f);
  return ord;
}
template <typename ll = int> vector<ll> mkiota(int N) {
  vector<ll> ret(N);
  iota(begin(ret), end(ret), 0);
  return ret;
}
static constexpr uint32_t get_r(int mod) {
  uint64_t ret = 1, m = mod, n = mod - 2;
  while (n) {
    ret = uint32_t(ret * m);
    m = uint32_t(m * m);
    n >>= 1;
  }
  return ret;
};

template <int mod> struct ModInt {
  int x;

  ModInt() : x(0) {}

  ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}

  ModInt &operator+=(const ModInt &p) {
    if ((x += p.x) >= mod)
      x -= mod;
    return *this;
  }

  ModInt &operator-=(const ModInt &p) {
    if ((x += mod - p.x) >= mod)
      x -= mod;
    return *this;
  }

  ModInt &operator*=(const ModInt &p) {
    x = (int)(1LL * x * p.x % mod);
    return *this;
  }

  ModInt &operator/=(const ModInt &p) {
    *this *= p.inverse();
    return *this;
  }

  ModInt operator-() const { return ModInt(-x); }

  ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }

  ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }

  ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }

  ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }

  bool operator==(const ModInt &p) const { return x == p.x; }

  bool operator!=(const ModInt &p) const { return x != p.x; }

  ModInt inverse() const {
    int a = x, b = mod, u = 1, v = 0, t;
    while (b > 0) {
      t = a / b;
      swap(a -= t * b, b);
      swap(u -= t * v, v);
    }
    return ModInt(u);
  }

  ModInt pow(int64_t n) const {
    ModInt ret(1), mul(x);
    while (n > 0) {
      if (n & 1)
        ret *= mul;
      mul *= mul;
      n >>= 1;
    }
    return ret;
  }

  friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }

  friend istream &operator>>(istream &is, ModInt &a) {
    int64_t t;
    is >> t;
    a = ModInt<mod>(t);
    return (is);
  }

  static constexpr int get_mod() { return mod; }
};

#pragma endregion

constexpr int MOD = /** 998244353;  //*/ 1000000007;
using mint = ModInt<MOD>;
using vm = vector<mint>;

template <typename T> struct edge {
  int src, to;
  T cost;

  edge(int to, T cost) : src(-1), to(to), cost(cost) {}
  edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}

  edge &operator=(const int &x) {
    to = x;
    return *this;
  }

  operator int() const { return to; }
};
template <typename T> using Edges = vector<edge<T>>;
template <typename T> using WeightedGraph = vector<Edges<T>>;
using UnweightedGraph = vector<vector<int>>;

// Input of (Unweighted) Graph
UnweightedGraph graph(int N, int M = -1, bool is_directed = false,
                      bool is_1origin = true) {
  UnweightedGraph g(N);
  if (M == -1)
    M = N - 1;
  for (int _ = 0; _ < M; _++) {
    int x, y;
    cin >> x >> y;
    if (is_1origin)
      x--, y--;
    g[x].pb(y);
    if (!is_directed)
      g[y].pb(x);
  }
  return g;
}

// Input of Weighted Graph
template <typename T>
WeightedGraph<T> wgraph(int N, int M = -1, bool is_directed = false,
                        bool is_1origin = true) {
  WeightedGraph<T> g(N);
  if (M == -1)
    M = N - 1;
  for (int _ = 0; _ < M; _++) {
    int x, y;
    cin >> x >> y;
    T c;
    cin >> c;
    if (is_1origin)
      x--, y--;
    g[x].eb(x, y, c);
    if (!is_directed)
      g[y].eb(y, x, c);
  }
  return g;
}

// Depth of Rooted Tree
// unvisited nodes : d = -1
vector<int> Depth(UnweightedGraph &g, int start = 0) {
  vector<int> d(g.size(), -1);
  auto dfs = [&](auto rec, int cur, int par = -1) -> void {
    d[cur] = par == -1 ? 0 : d[par] + 1;
    each(dst, g[cur]) {
      if (dst == par)
        continue;
      rec(rec, dst, cur);
    }
  };
  dfs(dfs, start);
  return d;
}

// Diameter of Tree
pair<int, int> Diameter(UnweightedGraph &g, int start = 0) {
  auto d = Depth(g, start);
  int u = max_element(begin(d), end(d)) - begin(d);
  d = Depth(g, u);
  int v = max_element(begin(d), end(d)) - begin(d);
  return make_pair(u, v);
}

void solve() {
  ini(N, K);
  vl a(N);
  in(a);
  if (N == K) {
    ll ans = 1;
    each(x, a) ans = ans * x % MOD;
    if (ans < 0)
      ans += MOD;
    die(ans);
  }

  vl p, m;
  each(x, a) {
    if (x > 0)
      p.push_back(x);
    else if (x < 0)
      m.push_back(x);
  }

  if (sz(p) + sz(m) < K)
    die(0);
  if (sz(p) + sz(m) == K) {
    if (sz(m) % 2 == 1)
      die(0);
    ll ans = 1;
    each(x, p) ans = ans * x % MOD;
    each(x, m) ans = ans * x % MOD;
    if (ans < 0)
      ans += MOD;
    die(ans);
  }

  sort(all(p), greater<>());
  sort(all(m));

  // 余剰がある->全部マイナスでない限り耐え
  if (sz(p) == 0) {
    if (K % 2 == 0) {
      ll ans = 1;
      rep(i, K) ans = ans * m[i] % MOD;
      if (ans < 0)
        ans += MOD;
      die(ans);
    } else if (sz(m) != N) {
      die(0);
    } else {
      reverse(all(m));
      ll ans = 1;
      rep(i, K) ans = ans * m[i] % MOD;
      if (ans < 0)
        ans += MOD;
      die(ans);
    }
  }

  vector<double> lp(sz(p)), lm(sz(m));
  rep(i, sz(p)) lp[i] = log(p[i]);
  rep(i, sz(m)) lm[i] = log(-m[i]);

  trc(p, lp);
  trc(m, lm);
  auto rp = mkrui(lp);
  auto rm = mkrui(lm);

  exit(1);
  // 適切をする
  long double cur = -100;
  int ci = -1;
  rep(i, K + 1) {
    int j = K - i;
    trc(i, j);
    if (j % 2 == 1)
      continue;
    if (i <= sz(p) and j <= sz(m)) {
      if (cur < rp[i] + rm[j]) {
        cur = rp[i] + rm[j];
        ci = i;
      }
    }
  }
  if (ci == -1)
    exit(1);
  ll ans = 1;
  rep(i, ci) ans = ans * p[i] % MOD;
  rep(i, K - ci) ans = ans * m[i] % MOD;
  if (ans < 0)
    ans += MOD;
  die(ans);
}