using namespace std;
using vi = vector<int>;
int main(void)
{
    int n;
    cin >> n;
    vi x(n);
    for (auto &xi : x)
        cin >> xi;
    sort(x.begin(), x.end());
    cout << distance(x.begin(), unique(x.begin(), x.end())) << endl;
    return 0;
}

using namespace std;
using ll = unsigned long long;
using predicate = function<bool(ll)>;
const ll NMAX = 2e5 + 11;
ll n, nprods, k[NMAX];
bool possible(ll t)
{
    return nprods <= accumulate(k, k + n, (ll)0, [t](ll acc, ll ki) -> ll {
               return acc + t / ki;
           });
}
ll bsearch(ll l, ll r, predicate p)
{
    while (l < r)
    {
        ll mid = l + (r - l) / 2;
        if (p(mid))
            r = mid;
        else
            l = mid + 1;
    }
    return l;
}
int main(void)
{
    cin >> n >> nprods;
    for (ll i = 0; i < n; ++i)
        cin >> k[i];
    cout << bsearch(0, 1e18 + 11, possible) << endl;
    return 0;
}

using namespace std;
using vi = vector<int>;
int const NMAX = 5e4 + 11;
int const KMAX = 5e2 + 11;
int n, k, dp[NMAX][KMAX], cnt;
vi g[NMAX];
void dfs(int u, int p = -1)
{
    dp[u][0] = 1;
    for (auto v : g[u])
    {
        if (v != p)
        {
            dfs(v, u);
            for (int i = 1; i <= k; i++)
                cnt += dp[v][i - 1] * dp[u][k - i];
            for (int i = 1; i <= k; i++)
                dp[u][i] += dp[v][i - 1];
        }
    }
}
int main(void)
{
    cin >> n >> k;
    for (int i = 1; i < n; i++)
    {
        int u, v;
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    dfs(1);
    cout << cnt << endl;
    return 0;
}

using namespace std;
using ii = pair<int, int>;
using vii = vector<ii>;
int main(void)
{
    int n, a, b, people = 0, ans = 0;
    cin >> n;
    vii events(2 * n);
    for (int i = 0; i < n; ++i)
    {
        cin >> a >> b;
        events[2 * i] = {a, +1};
        events[2 * i + 1] = {b, -1};
    }
    sort(events.begin(), events.end());
    for (auto [t, s] : events)
    {
        people += s;
        ans = max(ans, people);
    }
    cout << ans << endl;
    return 0;
}

using namespace std;
int solve(int n)
{
    if (n == 0)
        return 0;
    return n / 5 + solve(n / 5);
}
int main(void)
{
    int n;
    cin >> n;
    cout << solve(n) << endl;
    return 0;
}

using namespace std;
using ll = long long;
const int MOD = 1e9 + 7;
int solve(int n)
{
    ll ans = 1;
    for (int i = 0; i < n; ++i)
        ans = (ans * 2) % MOD;
    return ans;
}
int main(void)
{
    int n;
    cin >> n;
    cout << solve(n) << endl;
    return 0;
}

using namespace std;
using ll = long long;
using vi = vector<int>;
using mii = map<int, int>;
const int NMAX = 1e7 + 11;
bitset<NMAX> is_prime;
vector<int> prime;
mii prime_factors(ll n)
{
    mii factors;
    for (int j = 2; j <= n; ++j)
    {
        int ni = j;
        ll i = 0, pf = prime[i];
        while (pf * pf <= ni)
        {
            while (ni % pf == 0)
            {
                ++factors[pf];
                ni = ni / pf;
            }
            pf = prime[++i];
        }
        if (ni != 1)
            ++factors[ni];
    }
    return factors;
}
void sieve(ll maxn)
{
    ll sieve_size = maxn + 1;
    is_prime.set();
    is_prime[0] = is_prime[1] = 0;
    for (ll i = 2; i <= sieve_size; i++)
        if (is_prime[i])
        {
            for (ll j = i * i; j <= sieve_size; j += i)
                is_prime[j] = 0;
            prime.push_back((int)i);
        }
}
int main(void)
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    sieve(NMAX);
    int n;
    while (cin >> n and n)
    {
        cout << right << setw(3) << n;
        cout << "! =";
        int i = 0;
        for (auto elem : prime_factors(n))
        {
            if (i > 0 && i % 15 == 0)
                cout << endl << "      ";
            cout << right << setw(3) << elem.second;
            ++i;
        }
        cout << endl;
    }
    return 0;
}

using namespace std;
using ll = long long;
using ii = pair<int, int>;
using iii = array<int, 3>;
using vi = vector<int>;
int const NMAX = 200 + 11;
int n;
vi g[NMAX];
vector<ii> edges;
ii forbidden_edge;
bool is_forbidden(int u, int v)
{
    auto [up, vp] = forbidden_edge;
    return (u == up and v == vp) or (u == vp and v == up);
}
ii furthest_node(int u, int p, int d)
{
    ii ans = {d, u};
    for (int v : g[u])
    {
        if (v == p or is_forbidden(u, v))
            continue;
        ans = max(ans, furthest_node(v, u, d + 1));
    }
    return ans;
}
int find_diameter(int root)
{
    auto [d1, u] = furthest_node(root, -1, 0);
    auto [d2, v] = furthest_node(u, -1, 0);
    return d2;
}
int main(void)
{
    cin >> n;
    edges.resize(n);
    for (int i = 0; i < n - 1; ++i)
    {
        int u, v;
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
        edges[i] = {u, v};
    }
    int ans = 0;
    for (auto [u, v] : edges)
    {
        forbidden_edge = {u, v};
        int a = find_diameter(u), b = find_diameter(v);
        ans = max(ans, a * b);
    }
    cout << ans << endl;
    return 0;
}

using namespace std;
struct node
{
    int n4, n7;
    int n47, n74;
};
const int NMAX = 1e6 + 11;
int n, a[NMAX];
bool lazy[4 * NMAX];
node seg[4 * NMAX];
node merge(node u, node v)
{
    node ans;
    ans.n4 = u.n4 + v.n4;
    ans.n7 = u.n7 + v.n7;
    ans.n47 = max({u.n4 + v.n47, u.n47 + v.n7});
    ans.n74 = max({u.n7 + v.n74, u.n74 + v.n4});
    return ans;
}
inline node make_leaf(int d) { return {(d == 4), (d == 7), 1, 1}; }
void lazy_propagate(int v, int tl, int tr)
{
    swap(seg[v].n4, seg[v].n7);
    swap(seg[v].n47, seg[v].n74);
    if (tl != tr)
    {
        lazy[2 * v] = !lazy[2 * v];
        lazy[2 * v + 1] = !lazy[2 * v + 1];
    }
    lazy[v] = !lazy[v];
}
void build(int a[], int v, int tl, int tr)
{
    if (tl == tr)
        seg[v] = make_leaf(a[tl]);
    else
    {
        int tm = (tl + tr) / 2;
        build(a, 2 * v, tl, tm);
        build(a, 2 * v + 1, tm + 1, tr);
        seg[v] = merge(seg[2 * v], seg[2 * v + 1]);
    }
}
void update(int v, int tl, int tr, int ql, int qr)
{
    if (lazy[v])
        lazy_propagate(v, tl, tr);
    if (ql > qr)
        return;
    if (tl == ql and tr == qr)
    {
        lazy_propagate(v, tl, tr);
        lazy[v] = false;
    }
    else
    {
        int tm = (tl + tr) / 2;
        update(2 * v, tl, tm, ql, min(tm, qr));
        update(2 * v + 1, tm + 1, tr, max(tm + 1, ql), qr);
        seg[v] = merge(seg[2 * v], seg[2 * v + 1]);
    }
}
node query(int v, int tl, int tr, int ql, int qr)
{
    if (lazy[v])
        lazy_propagate(v, tl, tr);
    if (ql > qr)
        return {};
    if (tl == ql and tr == qr)
        return seg[v];
    else
    {
        int tm = (tl + tr) / 2;
        return merge(query(2 * v, tl, tm, ql, min(tm, qr)),
                     query(2 * v + 1, tm + 1, tr, max(tm + 1, ql), qr));
    }
}
int main(void)
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int q, l, r;
    string s, type;
    cin >> n >> q;
    cin >> s;
    for (int i = 0; i < n; ++i)
        a[i] = s[i] - '0';
    build(a, 1, 0, n - 1);
    while (q--)
    {
        cin >> type;
        if (type == "count")
        {
            node ans = query(1, 0, n - 1, 0, n - 1);
            cout << ans.n47 << endl;
        }
        else
        {
            cin >> l >> r;
            update(1, 0, n - 1, l - 1, r - 1);
        }
    }
    return 0;
}

using namespace std;
using ll = long long;
using ii = pair<ll, ll>;
using vi = vector<ll>;
ll const MOD = 998244353;
int const NMAX = 3e5 + 11;
ll fact[NMAX];
void precompute()
{
    fact[0] = 1;
    for (int i = 1; i < NMAX; i++)
        fact[i] = fact[i - 1] * i % MOD;
}
ll gcd(ll a, ll b, ll &x, ll &y)
{
    if (b == 0)
    {
        x = 1;
        y = 0;
        return a;
    }
    ll x1, y1;
    ll d = gcd(b, a % b, x1, y1);
    x = y1;
    y = x1 - y1 * (a / b);
    return d;
}
ll inv(int a)
{
    ll x, y;
    ll g = gcd(a, MOD, x, y);
    if (g != 1)
    {
        return 0;
    }
    else
    {
        return (x % MOD + MOD) % MOD;
    }
}
ll C(ll n, ll k)
{
    return fact[n] * inv(fact[k] * fact[n - k] % MOD) % MOD;
}
int main(void)
{
    ll n, k;
    cin >> n >> k;
    vector<ii> events(2 * n);
    for (int i = 0; i < n; ++i)
    {
        ll l, r;
        cin >> l >> r;
        events[2 * i] = {l, -1};
        events[2 * i + 1] = {r, +1};
    }
    sort(events.begin(), events.end());
    precompute();
    ll turned = 0;
    ll ans = 0;
    for (auto [t, sign] : events)
    {
        sign *= -1;
        if (sign == +1 and turned + sign >= k)
        {
            ans += (C(turned, k - 1)) % MOD;
        }
        turned += sign;
    }
    cout << ans % MOD << endl;
    return 0;
}