#include "insects.h"
#include <bits/stdc++.h>

using namespace std;
using ll = long long;

mt19937 rnd(228);

int min_cardinality(int N) {
    vector<int> a(N);
    iota(a.begin(), a.end(), 0);
    shuffle(a.begin(), a.end(), rnd);
    
    vector<int> leaders, inside(N);
    int maxSize = 0, T = 0, lastQueryT = 0;
    int queriesCnt[3]{};

    auto insert = [&](int x) -> void {
        if (inside[x]) {
            return;
        }
        move_inside(x);
        T += 1;
        queriesCnt[0] += 1;
        inside[x] = true;
    };

    auto erase = [&](int x) -> void {
        if (!inside[x]) {
            return;
        }
        move_outside(x);
        T += 1;
        queriesCnt[1] += 1;
        inside[x] = false;
    };

    auto query = [&]() -> int {
        if (T == lastQueryT) {
            return maxSize;
        }
        lastQueryT = T;
        queriesCnt[2] += 1;
        return maxSize = press_button();
    };

    vector<int> others, lo(N, -1), hi(N, -1);

    for (int x : a) {
        insert(x);
        if (query() == 1) {
            leaders.push_back(x);
        } else {
            others.push_back(x);
            lo[x] = -1, hi[x] = size(leaders) - 1;
            erase(x);
        }
    };

    int ans = N;

    int minPos = 0, maxPos = size(leaders), full = true;
    int m = size(leaders);
    vector<vector<int>> queries(m);
    vector<int> siz(m);

    while (true) {
        for (int i = 0; i < m; ++i) {
            queries[i].clear();
        }
        minPos = N, maxPos = 0;
        for (int i = 0; i < N; ++i) {
            if (lo[i] + 1 < hi[i]) {
                int mid = lo[i] + hi[i] >> 1;
                minPos = min(minPos, mid), maxPos = max(maxPos, mid);
                queries[lo[i] + hi[i] >> 1].push_back(i);
            }
        }
        if (minPos > maxPos) {
            break;
        }
        full = rnd() % 2;
        if (full) {
            for (int i = m - 1; i > maxPos; --i) {
                erase(leaders[i]);
            }
            for (int i = 0; i <= maxPos; ++i) {
                insert(leaders[i]);
            }
            for (int i = maxPos; i >= minPos; --i) {
                for (int x : queries[i]) {
                    insert(x);
                    if (query() == 2) {
                        hi[x] = i;
                        if (lo[x] + 1 < hi[x]) {
                            int mid = lo[x] + hi[x] >> 1;
                            if (mid >= minPos) {
                                queries[mid].push_back(x);
                            }
                        }
                    } else {
                        lo[x] = i;
                    }
                    erase(x);
                }
                if (i > minPos) {
                    erase(leaders[i]);
                }
            }
            full = false;
        } else {
            for (int i = m - 1; i > minPos; --i) {
                erase(leaders[i]);
            }
            for (int i = 0; i < minPos; ++i) {
                insert(leaders[i]);
            }
            for (int i = minPos; i <= maxPos; ++i) {
                insert(leaders[i]);
                for (int x : queries[i]) {
                    insert(x);
                    if (query() == 2) {
                        hi[x] = i;
                    } else {
                        lo[x] = i;
                        if (lo[x] + 1 < hi[x]) {
                            int mid = lo[x] + hi[x] >> 1;
                            if (mid <= maxPos) {
                                queries[mid].push_back(x);
                            }
                        }
                    }
                    erase(x);
                }
            }
            full = true;
        }
    }

    for (int i = 0; i < N; ++i) {
        if (hi[i] != -1) {
            siz[hi[i]] += 1;
        }
    }

    for (int i = 0; i < m; ++i) {
        ans = min(ans, 1 + siz[i]);
    }

    auto dfs = [&](auto dfs, vector<int> lead, vector<int> oth, int isFull) -> void {
        if (ans == 1) {
            return;
        }
        if (size(lead) == 1) {
            ans = min<int>(ans, 1 + size(oth));
            return;
        }
        if (size(lead) > size(oth)) {
            ans = 1;
            return;
        }
        int mid = size(lead) / 2;
        vector<int> leadLeft(lead.begin(), lead.begin() + mid);
        vector<int> leadRight(lead.begin() + mid, lead.end());
        vector<int> nxt[2];
        if (isFull) {
            for (int x : leadRight) {
                erase(x);
            }
        } else {
            for (int x : leadLeft) {
                insert(x);
            }
        }
        for (int x : oth) {
            insert(x);
            if (query() == 1) {
                nxt[1].push_back(x);
            } else {
                nxt[0].push_back(x);
            }
            erase(x);
        }
        dfs(dfs, leadLeft, nxt[0], true);
        dfs(dfs, leadRight, nxt[1], false);
    };

    // dfs(dfs, leaders, others, true);

    return ans;
}