// Hellolin v4.12.1
#include <bits/stdc++.h>
using namespace std;

#ifdef HELLOLIN_OPT
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math")
#endif

namespace hellolin {
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
using f32 = float;
using f64 = double;
#ifdef __SIZEOF_INT128__
using i128 = __int128_t;
using u128 = __uint128_t;
#endif
template <class T1, class T2>
bool checkMax(T1 &x, T2 y) { return x < y ? x = y, true : false; }
template <class T1, class T2>
bool checkMin(T1 &x, T2 y) { return x > y ? x = y, true : false; }
template <class T>
struct Vec : vector<T> {
  using vector<T>::vector;
  using Iter = typename vector<T>::iterator;
  using ConstIter = typename vector<T>::const_iterator;
  Vec()
      : vector<T>() {}
  Vec(const vector<T> &x)
      : vector<T>(x) {}
  void concat(const Vec &x) { this->insert(this->end(), x.begin(), x.end()); }
  void sort() { std::sort(this->begin(), this->end()); }
  template <class F>
  void sort(F f) { std::sort(this->begin(), this->end(), f); }
  void reverse() { std::reverse(this->begin(), this->end()); }
  T &operator[](size_t x) { return this->at(x); }
  const T &operator[](size_t x) const { return this->at(x); }
  Iter lbound(const T &x) { return lower_bound(this->begin(), this->end(), x); }
  Iter ubound(const T &x) { return upper_bound(this->begin(), this->end(), x); }
  ConstIter lbound(const T &x) const { return lower_bound(this->begin(), this->end(), x); }
  ConstIter ubound(const T &x) const { return upper_bound(this->begin(), this->end(), x); }
  bool bsearch(const T &x) const { return binary_search(this->begin(), this->end(), x); }
  Vec slice(size_t l, size_t r) const {
    if (l > r) {
      return {};
    }
    return Vec(this->begin(), r < this->size() ? this->begin() + r : this->end());
  }
  template <class P>
  Vec<P> map(function<P(T)> f) const {
    Vec<P> res(this->size());
    for (size_t i = 0; i < this->size(); ++i) {
      res[i] = f(this->at(i));
    }
    return res;
  }
};
class IO {
  static constexpr int Buffer = 1 << 19;
  char ibuf[Buffer], *ist, *ied;
  char obuf[Buffer], *ost, *oed;
  FILE *ifile = stdin, *ofile = stdout;

public:
  IO() {
    ist = ied = ibuf;
    ost = obuf, oed = obuf + Buffer - 1;
  }
  ~IO() { flush(); }
  void reopen(const char *a, const char *b) {
    flush();
    ifile = fopen(a, "r");
    ofile = fopen(b, "w");
  }
  char getChar() {
    if (ist == ied) {
      ied = (ist = ibuf) + fread(ibuf, 1, Buffer, ifile);
      if (ist == ied) {
        return EOF;
      }
    }
    return *ist++;
  }
  void putChar(char x) {
    *ost++ = x;
    if (ost == oed) {
      flush();
    }
  }
  void flush() {
    fwrite(obuf, 1, ost - obuf, ofile);
    ost = obuf;
    fflush(ofile);
  }
  void read(char &x) {
    do {
      x = getChar();
    } while (!isgraph(x));
  }
  void read(string &x) {
    x = "";
    char c = getChar();
    for (; !isgraph(c); c = getChar())
      ;
    for (; isgraph(c); c = getChar()) {
      x += c;
    }
  }
  template <class T>
  void read(T &x) {
    x = 0;
    char c = getChar();
    bool neg = false;
    for (; !isdigit(c); c = getChar()) {
      neg ^= c == '-';
    }
    for (; isdigit(c); c = getChar()) {
      x = x * 10 + c - 48;
    }
    x = neg ? -x : x;
  }
  template <class T, class... A>
  void read(T &x, A &...a) { read(x), read(a...); }
  void write() {}
  void write(char x) { putChar(x); }
  void write(const string &x) {
    for (const char &i : x) {
      putChar(i);
    }
  }
  template <class T>
  void write(T x) {
    write(to_string(x));
  }
  template <class T, class... A>
  void write(T x, A... a) { write(x), write(a...); }
  template <class... A>
  void writeln(A... a) { write(a...), putChar('\n'); }
} io;
void main();
} // namespace hellolin

int main() {
#ifndef HELLOLIN_STDIO
  // hellolin::io.reopen("sort.in", "sort.out");
#endif
  hellolin::main();
}

namespace hellolin {
void main() {
  for (; ;) {
    int n = -1, m = -1;
    io.read(n, m);
	if(n == -1 && m == -1) {
	  return;
	}
    if(n == 1) {
      io.writeln(0);
      continue;
    }
    Vec<i64> fac(n + 1), ifc(n + 1);
    fac[0] = ifc[0] = 1;
    for (int i = 1; i <= n; ++i) {
      fac[i] = fac[i - 1] * i % m;
    }
    auto pow = [&](i64 x, int y) {
      i64 res = 1;
      for (; y; y >>= 1, (x *= x) %= m) {
        if (y & 1) {
          (res *= x) %= m;
        }
      }
      return res;
    };
    ifc[n] = pow(fac[n], m - 2);
    for (int i = n; i >= 2; --i) {
      ifc[i - 1] = ifc[i] * i % m;
    }
    auto comb = [&](int x, int y) -> i64 {
      if(y < 0 || x < y) return 0;
      return fac[x] * ifc[y] % m * ifc[x - y] % m;
    };
    i64 ans = 0, pre = 1;
    for (int i = 0; i < n; ++i) {
      ans += pre * comb(n - 1, n - i - 1) % m * comb(n - 1, n - i) % m;
      ans %= m;
      (pre <<= 1) %= m;
    }
    ans = (fac[n] - pow(n - 1, m - 2) * ans % m) % m + m;
    io.writeln(ans % m);
  }
}
} // namespace hellolin