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

typedef long long ll;

typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<int, ll> pil;
typedef pair<ll, ll> pll;

#define mp make_pair
#define fr first
#define sc second

// full credit ecnerwala
template <int& MOD_>
struct modint {
    static constexpr int& MOD = MOD_;
    // static_assert(MOD_ > 0, "MOD must be positive");

   private:
    using ll = long long;

    int v;

    static int minv(int a, int m) {
        a %= m;
        assert(a);
        return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
    }

   public:
    modint() : v(0) {}
    modint(ll v_) : v(int(v_ % MOD)) {
        if (v < 0) v += MOD;
    }
    explicit operator int() const { return v; }
    friend std::ostream& operator<<(std::ostream& out, const modint& n) {
        return out << int(n);
    }
    friend std::istream& operator>>(std::istream& in, modint& n) {
        ll v_;
        in >> v_;
        n = modint(v_);
        return in;
    }

    friend bool operator==(const modint& a, const modint& b) {
        return a.v == b.v;
    }
    friend bool operator!=(const modint& a, const modint& b) {
        return a.v != b.v;
    }

    modint inv() const {
        modint res;
        res.v = minv(v, MOD);
        return res;
    }
    friend modint inv(const modint& m) { return m.inv(); }
    modint neg() const {
        modint res;
        res.v = v ? MOD - v : 0;
        return res;
    }
    friend modint neg(const modint& m) { return m.neg(); }

    modint operator-() const { return neg(); }
    modint operator+() const { return modint(*this); }

    modint& operator++() {
        v++;
        if (v == MOD) v = 0;
        return *this;
    }
    modint& operator--() {
        if (v == 0) v = MOD;
        v--;
        return *this;
    }
    modint& operator+=(const modint& o) {
        v -= MOD - o.v;
        v = (v < 0) ? v + MOD : v;
        return *this;
    }
    modint& operator-=(const modint& o) {
        v -= o.v;
        v = (v < 0) ? v + MOD : v;
        return *this;
    }
    modint& operator*=(const modint& o) {
        v = int(ll(v) * ll(o.v) % MOD);
        return *this;
    }
    modint& operator/=(const modint& o) { return *this *= o.inv(); }

    friend modint operator++(modint& a, int) {
        modint r = a;
        ++a;
        return r;
    }
    friend modint operator--(modint& a, int) {
        modint r = a;
        --a;
        return r;
    }
    friend modint operator+(const modint& a, const modint& b) {
        return modint(a) += b;
    }
    friend modint operator-(const modint& a, const modint& b) {
        return modint(a) -= b;
    }
    friend modint operator*(const modint& a, const modint& b) {
        return modint(a) *= b;
    }
    friend modint operator/(const modint& a, const modint& b) {
        return modint(a) /= b;
    }
    modint qpow(ll pow) const {
        modint ans = 1, base = v;
        while (pow) {
            if (pow & 1) ans *= base;
            base *= base;
            pow >>= 1;
        }
        return ans;
    }
    friend modint qpow(const modint& a, ll pow) { return a.qpow(pow); }
};

int MOD;

void solve() {
    ll N;
    int M;
    cin >> N >> M;
    MOD = M * M;
    using mint = modint<MOD>;
    cout << (int)qpow(mint(10), N) / M % M << '\n';
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif

    int t = 1;
    // cin >> t;
    while (t--) solve();

    return 0;
}

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

#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define all(x) (x).begin(),(x).end()
using ll = long long;
using P = pair<ll, ll>;
string char_to_string(char val) {
  return string(1, val);
}
int char_to_int(char val) {
  return val - '0';
}
template<class T> inline bool chmin(T& a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template<class T> inline bool chmax(T& a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
struct edge {
  ll to, cost;
};

int main() {
  ll n; cin >> n;
  ll N = n + 1;
  ll res = 0; ll i = 1;
  while(N > res) {
    res += i;
    if(N < res) break;
    ++i;
  }
  if(n == 2) cout << 1 << endl;
  else cout << n - (i - 1) + 1 << endl;
}