牛客多校补题

第一场

1.容斥计数

给定 $n,m,q$，求满足如下要求的序列个数模 $q$ 的结果：

• 长度为 $n$
• 存在两个不同的子序列，满足子序列中的数区间与为1
• 序列中的数的大小范围在 $[0,2^m)$

数据范围： $n \leq 5000,m \leq 5000,q \leq 10^9$

分析什么时候存在两个子序列满足上述条件。考虑该序列长度为 $k$ 的全部奇数组成的子序列 $B$，容易证明若该序列存在区间与为 1 的子序列，则 $B$ 是最大的满足区间与是 1 的子序列。考虑容斥，即计算满足比 $B$ 小的子序列区间与都不为 1 的 $b$ 的 $B$ 的个数，记这个条件为 $P$ 。也就是

$\forall x \in B,\exists i \leq \_\_\lg(x),x是B中唯一满足2^i \And x= 0的元素$

考虑枚举式子中的 $i$ ，称这个 $i$ 为特殊位当且仅当存在 $B$ 中的元素满足上述条件。根据逻辑推理的知识，容易证明这两个条件是等价的。

于是我们记 $dp_{i,j}$ 表示满足长度为 $i$，恰好有 $j$ 个特殊位的的奇数序列个数。考虑转移，假设有如下状态，数字纵向排列

$\begin{array}{cccc} 1 & 0 & 1 & 1\\ 1 & 1 & 1 & 0\\ 1 &1 &0 &1\end{array}$

对应状态 $(3,4)$ 。

它可以向如下矩阵转移

$\begin{array}{ccccc} 1 & 0 & 1 & 1 & 1\\ 1 & 1 & 1 & 0 & \textbf 0\\ 1 &1 &0 &1 & 1\end{array}$

对应状态 $(3,5)$ 。

注意粗体的 $0$ 可以有 $i$ 种选择，因此转移系数是 $i$ 。

还可以向如下矩阵转移

$\begin{array}{ccccc} 1 & 0 & 1 & 1 & 1\\ 1 & 1 & 1 & 0 & 1\\ 1 &1 &0 &1 & 1\\ \textbf 1 &\textbf 1 &\textbf 1 &\textbf 1 &\textbf 0\end{array}$

对应状态 $(4,5)$ 。

注意，粗体的数字 $11110$ 可以被插在任意行，它所对应的序列是不同的，因此转移系数也是 $i$ 。

综上可以有转移方程

$dp_{i + 1,j + 1}=i(dp_{i,j}+dp_{i+1,j})$

求出 $dp$ 之后，我们固定 $B$ 的长度 $k(k\geq2)$ 以及特殊位的个数 $t$ ，就有满足 $P$ 的序列个数为

$P(k,t)=dp_{k,t}(2^k-1-k)^{m-t-1}$

加上偶数，我们就有结果

$B(k,t)=\dbinom{n}{k}(2^{m-1})^{n-k}\dbinom{m-1}{t}P(k,t)\\|B|=n(2^{m-1})^{n-1}+\sum_{k=2}^{n}\dbinom{n}{k}(2^{m-1})^{n-k} \sum_{t=k}^{m-1}\dbinom{m-1}{t}P(k,t)$

于是引用上一题的答案，我们就有最终式子

$\big(\sum_{k=1}^{n}\dbinom{n}{k}2^{(m-1)(n-k)}(2^k-1)^m \big)-|B|$

时间复杂度 $O((n + m)^2)$ 。

code:

#pragma GCC optimize("O3")
#include <bits/stdc++.h>


#include <utility>

namespace atcoder {

namespace internal {

// @param m `1 <= m`
// @return x mod m
constexpr long long safe_mod(long long x, long long m) {
    x %= m;
    if (x < 0) x += m;
    return x;
}

// Fast modular multiplication by barrett reduction
// Reference: https://en.wikipedia.org/wiki/Barrett_reduction
// NOTE: reconsider after Ice Lake
struct barrett {
    unsigned int _m;
    unsigned long long im;

    // @param m `1 <= m < 2^31`
    barrett(unsigned int m) : _m(m), im((unsigned long long)(-1) / m + 1) {}

    // @return m
    unsigned int umod() const { return _m; }

    // @param a `0 <= a < m`
    // @param b `0 <= b < m`
    // @return `a * b % m`
    unsigned int mul(unsigned int a, unsigned int b) const {
        // [1] m = 1
        // a = b = im = 0, so okay

        // [2] m >= 2
        // im = ceil(2^64 / m)
        // -> im * m = 2^64 + r (0 <= r < m)
        // let z = a*b = c*m + d (0 <= c, d < m)
        // a*b * im = (c*m + d) * im = c*(im*m) + d*im = c*2^64 + c*r + d*im
        // c*r + d*im < m * m + m * im < m * m + 2^64 + m <= 2^64 + m * (m + 1) < 2^64 * 2
        // ((ab * im) >> 64) == c or c + 1
        unsigned long long z = a;
        z *= b;
#ifdef _MSC_VER
        unsigned long long x;
        _umul128(z, im, &x);
#else
        unsigned long long x =
            (unsigned long long)(((unsigned __int128)(z)*im) >> 64);
#endif
        unsigned int v = (unsigned int)(z - x * _m);
        if (_m <= v) v += _m;
        return v;
    }
};

// @param n `0 <= n`
// @param m `1 <= m`
// @return `(x ** n) % m`
constexpr long long pow_mod_constexpr(long long x, long long n, int m) {
    if (m == 1) return 0;
    unsigned int _m = (unsigned int)(m);
    unsigned long long r = 1;
    unsigned long long y = safe_mod(x, m);
    while (n) {
        if (n & 1) r = (r * y) % _m;
        y = (y * y) % _m;
        n >>= 1;
    }
    return r;
}

// Reference:
// M. Forisek and J. Jancina,
// Fast Primality Testing for Integers That Fit into a Machine Word
// @param n `0 <= n`
constexpr bool is_prime_constexpr(int n) {
    if (n <= 1) return false;
    if (n == 2 || n == 7 || n == 61) return true;
    if (n % 2 == 0) return false;
    long long d = n - 1;
    while (d % 2 == 0) d /= 2;
    constexpr long long bases[3] = {2, 7, 61};
    for (long long a : bases) {
        long long t = d;
        long long y = pow_mod_constexpr(a, t, n);
        while (t != n - 1 && y != 1 && y != n - 1) {
            y = y * y % n;
            t <<= 1;
        }
        if (y != n - 1 && t % 2 == 0) {
            return false;
        }
    }
    return true;
}
template <int n> constexpr bool is_prime = is_prime_constexpr(n);

// @param b `1 <= b`
// @return pair(g, x) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g
constexpr std::pair<long long, long long> inv_gcd(long long a, long long b) {
    a = safe_mod(a, b);
    if (a == 0) return {b, 0};

    // Contracts:
    // [1] s - m0 * a = 0 (mod b)
    // [2] t - m1 * a = 0 (mod b)
    // [3] s * |m1| + t * |m0| <= b
    long long s = b, t = a;
    long long m0 = 0, m1 = 1;

    while (t) {
        long long u = s / t;
        s -= t * u;
        m0 -= m1 * u;  // |m1 * u| <= |m1| * s <= b

        // [3]:
        // (s - t * u) * |m1| + t * |m0 - m1 * u|
        // <= s * |m1| - t * u * |m1| + t * (|m0| + |m1| * u)
        // = s * |m1| + t * |m0| <= b

        auto tmp = s;
        s = t;
        t = tmp;
        tmp = m0;
        m0 = m1;
        m1 = tmp;
    }
    // by [3]: |m0| <= b/g
    // by g != b: |m0| < b/g
    if (m0 < 0) m0 += b / s;
    return {s, m0};
}

// Compile time primitive root
// @param m must be prime
// @return primitive root (and minimum in now)
constexpr int primitive_root_constexpr(int m) {
    if (m == 2) return 1;
    if (m == 167772161) return 3;
    if (m == 469762049) return 3;
    if (m == 754974721) return 11;
    if (m == 998244353) return 3;
    int divs[20] = {};
    divs[0] = 2;
    int cnt = 1;
    int x = (m - 1) / 2;
    while (x % 2 == 0) x /= 2;
    for (int i = 3; (long long)(i)*i <= x; i += 2) {
        if (x % i == 0) {
            divs[cnt++] = i;
            while (x % i == 0) {
                x /= i;
            }
        }
    }
    if (x > 1) {
        divs[cnt++] = x;
    }
    for (int g = 2;; g++) {
        bool ok = true;
        for (int i = 0; i < cnt; i++) {
            if (pow_mod_constexpr(g, (m - 1) / divs[i], m) == 1) {
                ok = false;
                break;
            }
        }
        if (ok) return g;
    }
}
template <int m> constexpr int primitive_root = primitive_root_constexpr(m);

}  // namespace internal

}  // namespace atcoder


#include <cassert>
#include <numeric>
#include <type_traits>

namespace atcoder {

namespace internal {

#ifndef _MSC_VER
template <class T>
using is_signed_int128 =
    typename std::conditional<std::is_same<T, __int128_t>::value ||
                                  std::is_same<T, __int128>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using is_unsigned_int128 =
    typename std::conditional<std::is_same<T, __uint128_t>::value ||
                                  std::is_same<T, unsigned __int128>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using make_unsigned_int128 =
    typename std::conditional<std::is_same<T, __int128_t>::value,
                              __uint128_t,
                              unsigned __int128>;

template <class T>
using is_integral = typename std::conditional<std::is_integral<T>::value ||
                                                  is_signed_int128<T>::value ||
                                                  is_unsigned_int128<T>::value,
                                              std::true_type,
                                              std::false_type>::type;

template <class T>
using is_signed_int = typename std::conditional<(is_integral<T>::value &&
                                                 std::is_signed<T>::value) ||
                                                    is_signed_int128<T>::value,
                                                std::true_type,
                                                std::false_type>::type;

template <class T>
using is_unsigned_int =
    typename std::conditional<(is_integral<T>::value &&
                               std::is_unsigned<T>::value) ||
                                  is_unsigned_int128<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using to_unsigned = typename std::conditional<
    is_signed_int128<T>::value,
    make_unsigned_int128<T>,
    typename std::conditional<std::is_signed<T>::value,
                              std::make_unsigned<T>,
                              std::common_type<T>>::type>::type;

#else

template <class T> using is_integral = typename std::is_integral<T>;

template <class T>
using is_signed_int =
    typename std::conditional<is_integral<T>::value && std::is_signed<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using is_unsigned_int =
    typename std::conditional<is_integral<T>::value &&
                                  std::is_unsigned<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using to_unsigned = typename std::conditional<is_signed_int<T>::value,
                                              std::make_unsigned<T>,
                                              std::common_type<T>>::type;

#endif

template <class T>
using is_signed_int_t = std::enable_if_t<is_signed_int<T>::value>;

template <class T>
using is_unsigned_int_t = std::enable_if_t<is_unsigned_int<T>::value>;

template <class T> using to_unsigned_t = typename to_unsigned<T>::type;

}  // namespace internal

}  // namespace atcoder

#include <cassert>
#include <numeric>
#include <type_traits>

#ifdef _MSC_VER
#include <intrin.h>
#endif

namespace atcoder {

namespace internal {

struct modint_base {};
struct static_modint_base : modint_base {};

template <class T> using is_modint = std::is_base_of<modint_base, T>;
template <class T> using is_modint_t = std::enable_if_t<is_modint<T>::value>;

}  // namespace internal

template <int m, std::enable_if_t<(1 <= m)>* = nullptr>
struct static_modint : internal::static_modint_base {
    using mint = static_modint;

  public:
    static constexpr int mod() { return m; }
    static mint raw(int v) {
        mint x;
        x._v = v;
        return x;
    }

    static_modint() : _v(0) {}
    template <class T, internal::is_signed_int_t<T>* = nullptr>
    static_modint(T v) {
        long long x = (long long)(v % (long long)(umod()));
        if (x < 0) x += umod();
        _v = (unsigned int)(x);
    }
    template <class T, internal::is_unsigned_int_t<T>* = nullptr>
    static_modint(T v) {
        _v = (unsigned int)(v % umod());
    }
    static_modint(bool v) { _v = ((unsigned int)(v) % umod()); }

    unsigned int val() const { return _v; }

    mint& operator++() {
        _v++;
        if (_v == umod()) _v = 0;
        return *this;
    }
    mint& operator--() {
        if (_v == 0) _v = umod();
        _v--;
        return *this;
    }
    mint operator++(int) {
        mint result = *this;
        ++*this;
        return result;
    }
    mint operator--(int) {
        mint result = *this;
        --*this;
        return result;
    }

    mint& operator+=(const mint& rhs) {
        _v += rhs._v;
        if (_v >= umod()) _v -= umod();
        return *this;
    }
    mint& operator-=(const mint& rhs) {
        _v -= rhs._v;
        if (_v >= umod()) _v += umod();
        return *this;
    }
    mint& operator*=(const mint& rhs) {
        unsigned long long z = _v;
        z *= rhs._v;
        _v = (unsigned int)(z % umod());
        return *this;
    }
    mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }

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

    mint pow(long long n) const {
        assert(0 <= n);
        mint x = *this, r = 1;
        while (n) {
            if (n & 1) r *= x;
            x *= x;
            n >>= 1;
        }
        return r;
    }
    mint inv() const {
        if (prime) {
            assert(_v);
            return pow(umod() - 2);
        } else {
            auto eg = internal::inv_gcd(_v, m);
            assert(eg.first == 1);
            return eg.second;
        }
    }

    friend mint operator+(const mint& lhs, const mint& rhs) {
        return mint(lhs) += rhs;
    }
    friend mint operator-(const mint& lhs, const mint& rhs) {
        return mint(lhs) -= rhs;
    }
    friend mint operator*(const mint& lhs, const mint& rhs) {
        return mint(lhs) *= rhs;
    }
    friend mint operator/(const mint& lhs, const mint& rhs) {
        return mint(lhs) /= rhs;
    }
    friend bool operator==(const mint& lhs, const mint& rhs) {
        return lhs._v == rhs._v;
    }
    friend bool operator!=(const mint& lhs, const mint& rhs) {
        return lhs._v != rhs._v;
    }

  private:
    unsigned int _v;
    static constexpr unsigned int umod() { return m; }
    static constexpr bool prime = internal::is_prime<m>;
};

template <int id> struct dynamic_modint : internal::modint_base {
    using mint = dynamic_modint;

  public:
    static int mod() { return (int)(bt.umod()); }
    static void set_mod(int m) {
        assert(1 <= m);
        bt = internal::barrett(m);
    }
    static mint raw(int v) {
        mint x;
        x._v = v;
        return x;
    }

    dynamic_modint() : _v(0) {}
    template <class T, internal::is_signed_int_t<T>* = nullptr>
    dynamic_modint(T v) {
        long long x = (long long)(v % (long long)(mod()));
        if (x < 0) x += mod();
        _v = (unsigned int)(x);
    }
    template <class T, internal::is_unsigned_int_t<T>* = nullptr>
    dynamic_modint(T v) {
        _v = (unsigned int)(v % mod());
    }
    dynamic_modint(bool v) { _v = ((unsigned int)(v) % mod()); }

    unsigned int val() const { return _v; }

    mint& operator++() {
        _v++;
        if (_v == umod()) _v = 0;
        return *this;
    }
    mint& operator--() {
        if (_v == 0) _v = umod();
        _v--;
        return *this;
    }
    mint operator++(int) {
        mint result = *this;
        ++*this;
        return result;
    }
    mint operator--(int) {
        mint result = *this;
        --*this;
        return result;
    }

    mint& operator+=(const mint& rhs) {
        _v += rhs._v;
        if (_v >= umod()) _v -= umod();
        return *this;
    }
    mint& operator-=(const mint& rhs) {
        _v += mod() - rhs._v;
        if (_v >= umod()) _v -= umod();
        return *this;
    }
    mint& operator*=(const mint& rhs) {
        _v = bt.mul(_v, rhs._v);
        return *this;
    }
    mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }

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

    mint pow(long long n) const {
        assert(0 <= n);
        mint x = *this, r = 1;
        while (n) {
            if (n & 1) r *= x;
            x *= x;
            n >>= 1;
        }
        return r;
    }
    mint inv() const {
        auto eg = internal::inv_gcd(_v, mod());
        assert(eg.first == 1);
        return eg.second;
    }

    friend mint operator+(const mint& lhs, const mint& rhs) {
        return mint(lhs) += rhs;
    }
    friend mint operator-(const mint& lhs, const mint& rhs) {
        return mint(lhs) -= rhs;
    }
    friend mint operator*(const mint& lhs, const mint& rhs) {
        return mint(lhs) *= rhs;
    }
    friend mint operator/(const mint& lhs, const mint& rhs) {
        return mint(lhs) /= rhs;
    }
    friend bool operator==(const mint& lhs, const mint& rhs) {
        return lhs._v == rhs._v;
    }
    friend bool operator!=(const mint& lhs, const mint& rhs) {
        return lhs._v != rhs._v;
    }

  private:
    unsigned int _v;
    static internal::barrett bt;
    static unsigned int umod() { return bt.umod(); }
};
template <int id> internal::barrett dynamic_modint<id>::bt = 998244353;

using modint998244353 = static_modint<998244353>;
using modint1000000007 = static_modint<1000000007>;
using modint = dynamic_modint<-1>;

namespace internal {

template <class T>
using is_static_modint = std::is_base_of<internal::static_modint_base, T>;

template <class T>
using is_static_modint_t = std::enable_if_t<is_static_modint<T>::value>;

template <class> struct is_dynamic_modint : public std::false_type {};
template <int id>
struct is_dynamic_modint<dynamic_modint<id>> : public std::true_type {};

template <class T>
using is_dynamic_modint_t = std::enable_if_t<is_dynamic_modint<T>::value>;

}  // namespace internal

}  // namespace atcoder


//#define int long long
using ll = long long;
const ll mod = 998244353;
const int N = 1e7 + 7;



typedef atcoder::modint MINT;

void solve() {
  
    int n,m,q;std::cin>>n>>m>>q;
    MINT::set_mod(q);

    std::vector<std::vector<MINT>> dp(n + m + 2,std::vector<MINT>(m + n + 2,0));
  
    dp[0][0] = 1;
    for(int i = 1;i <= n;i++){
        for(int j = 1;j < m;j++)
            dp[i][j] = i * (dp[i][j - 1] + dp[i - 1][j - 1]);
    }

    MINT ans1 = 0;
  

    std::vector<std::vector<MINT> > C(5050,std::vector<MINT>(5050,0));
    std::vector<MINT> po2(5050,0);

  
    po2[0] = 1;
    for(int i = 1;i <= 5000;i++)po2[i] = po2[i - 1] * 2;
    C[0][0] = 1;
    for(int i = 1;i <= 5000;i++){
        C[i][0] = 1;
        for(int j = 1;j <= i;j++)
            C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]);
    }

    for(int i = 2;i <= n;i++){
        MINT cur = 1,cur1 = 1;
        for(int j = 1;j < m;j++) cur *= (po2[i] - 1),cur1 *= po2[n - i];
        ans1 += C[n][i] * cur1 * cur;
    }
    //std::cout<<ans1<<'\n';

    MINT ans2 = 0;
    std::vector<MINT> pw(m + 2);
    for(int i = 2;i <= n;i++){
        MINT tp = 0;
        pw[0] = 1;
        for(int j = 1;j <= m;j++)pw[j] = pw[j - 1] * (po2[i] - 1 - i);
        for(int j = m - 1;j >= i;j--){
            tp += C[m - 1][j] * dp[i][j] * pw[m - j - 1];
        }
        MINT cur = 1;
        for(int j = 1;j < m;j++) cur *= po2[n - i];
        tp *= C[n][i] * cur;
        ans2 += tp;
    }

    std::cout<<(ans1 - ans2).val()<<'\n';
}
// 1 3 10
//(n  + 1) ^2 - (n)^ = 2n + 1

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    int t = 1;
    // int res = 0;
    // for(int i = 1;i <= 1145;i++) res |= i;
    // std::cerr<<res<<'\n';
    //std::cin >> t;
    while (t--) {
        solve();
        std::cout.flush();
    }
    return 0;
}

---

2.模意义下的不等式

给定一数组 $a$ ，初始为空。定义一次操作为

• 将数组末尾 $t$ 个元素删去
• 将元素 $x$ 添加至数组末尾

每次操作给定 $t,x$，保证操作合法，求每次操作后的

$\bigoplus_{i=1}^{|a|}(\sum_{j=i}^{|a|}a_i) \mod 2^{20}$

数据范围：$q\leq 5 \cdot 10^5, x \leq 10^9$

首先考虑到模数，只需要考虑 20 位及以下的贡献。异或，拆位分析奇偶。

设当前位数为 $d$ ，我们记前缀和为 $S_i$，则对于某个位置 $i$，$\sum_{j=i}^{|a|}a_i$ 的第 $d$ 位是 1 的充要条件是

$(S_{|a|}-S_i) \mod 2^{d + 1} \geq 2^d \tag{1}$

因为模一个整的 $k$ 位 $2$ 进制数相当于将原数 $k$ 位以上的二进制位消去。类比十进制即可证明。

$S$ 是好维护的，我们考虑 $(1)$ 如何维护。这是一个循环群上的不等式，先将 $S_i$ 处理为逆元，即将上式变为

$S_{|a|}+(-S_i) \geq 2^d \tag{1}$

上式所有量都是模意义下的量。我们分类讨论

1. $0\leq S_{|a|}<2^d$，显然地就有 $(-S_i) \in [2^d-S_{|a|},2^{d+1}-S_{|a|}]$
2. $S_{|a|}\geq 2^d$，这时候区间分成了两段，$(0,2^{d+1}-S_{|a|}]\cup[S_{|a|} - 2^d,2^{d+1})$

画一个圆圈即可理解。考虑到 $1e6 $ 的值域和 6s 的时限，我们可以开 20 个模意义下的权值树状数组，每次操作后按位求出区间内的 $1$ 的奇偶性即可。

code

#include <bits/stdc++.h>

using ll = long long;
const int mod[24] = {1,2,4,8,1<<4,1<<5,1<<6,1<<7,1<<8,1<<9,1<<10,1<<11,1<<12,1<<13,1<<14,1<<15,1<<16,1<<17,1<<18,1<<19,1<<20,1<<21};

//const ll mod = 1e9 + 7;
// #define int long long

class bit {
   public:
    int a[1<<22];
    int n;
    bit(int n) : n(n + 4) {
        for(int i = 1;i <= n;i++)a[i] = 0;
    }

    bit() { n = 0; }

    void add(int x, int y) {
        x++;
        for (int i = x; i <= n; i += i & -i) {
            a[i] += y;
        }
    }
    int get(int x) {
        x++;
        int res = 0;
        if(x <= 0) return 0;
        for (int i = x; i; i -= i & -i) {
            res += a[i];
        }
        return res;
    }

    int get(int l, int r) {
        // l++,r++;
        l = std::max(l,0);
        r = std::min(n,r);
        if(l == 0) return get(r);
        return get(r) - get(l - 1);
    }
};

inline void read(int &x) {
    x = 0;
    char c = getchar();
    while (!isdigit(c)) c = getchar();
    while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
}

int sum[500050];
int idx;

void solve() {
    std::vector<bit> a(21);

    auto add = [&](int x) {
        for (int i = 0; i < 21; i++){
            int tp = x % mod[i + 1];
            //std::cerr<<tp<<' '<<x<<'\n';
            a[i].add(tp, 1);
        }
    };

    auto rm = [&](int x) {
        for (int i = 0; i < 21; i++){
            int tp = x % mod[i + 1];
            a[i].add(tp, -1);
        }
    };

    for (int i = 0; i < 21; i++) {
        a[i] = bit(1 << (i + 1));
    }
    add(0);

    int q;
    read(q);
    //std::stack<int> sum;
    while (q--) {
        int t, x;
        read(t), read(x);

        for (int i = 1; i <= t; i++)
            rm(sum[idx]), idx--;
        if (idx == 0)
            sum[idx + 1] = x;
        else
            sum[idx + 1] = x + sum[idx];
        idx++;
        // std::cerr<<sum.back()<<'\n';0
        add(sum[idx]);

        int res = 0;
        for (int i = 0; i < 21; i++) {
            int l = 0, r = 0;
            int l1 = 0, r1 = 0;
            int tp = (sum[idx] + 1) % mod[i + 1];
            //if(tp == 0)tp = (1ll << (i + 1));
            int tp1 = 0;
            if (tp < (1ll << i)) {
                l = tp, r = (1 << i) + tp - 1;
                //std::cerr<<l<<' '<<r<<'\n';
                tp1 = a[i].get(l, r);
            } else {
                l = 0, r = tp - (1<<i) - 1, l1 = tp, r1 = (1 << i + 1) - 1;
                //std::cerr<<l<<' '<<r<<' '<<l1<<' '<<r1<<'\n';
                tp1 = a[i].get(l, r) ^ a[i].get(l1, r1);
            }
            // r &= (1<<i);
            res |= (tp1 & 1) * (1ll << i);
        }

        std::cout << res << '\n';
        std::cout.flush();
    }
}

signed main() {
    //std::ios::sync_with_stdio(false);
    //std::cin.tie(0);
    int t = 1;
    // std::cin >> t;
    while (t--) {
        solve();
        // std::cout.flush();
    }
    // std::cout<<5 * inv(2ll) % mod<<'\n';
    return 0;
}