线性基

struct XorBasis
{
    typedef ll type;

    vectorG;
    bool zero;

    XorBasis() {clear();}

    void insert(type x)
    {
        for(int i=sz(G)-1;~i && x;--i)
        {
            type t=x^G[i];
            if(tG[i])break;
                x^=G[i];
            }
        }
        if(!x){zero=true;return;}
        G.pb(x);
        for(int i=sz(G)-1;i && G[i]=0;--i)
            if((res^G[i])>res)
                res^=G[i];
        return res;
    }

    type kth(ll k)
    {
        if(zero && !--k)return 0;
        if(k>=(1ll<=0;--i)
        {
            type x=(1ll<=x)k-=x,ans^=G[i];
            if(!k)return ans;
        }
        return ans;
    }

    int size() {return G.size()+zero;}

    void clear()
    {
        zero=false;
        G.clear();
    }
}X;

可持久化线性基

struct PersistentXorBasis
{
    static const int __=5e5+5;
    typedef int type;

    struct XorBasis
    {
        vector >G;
        int zero;   //最后出现的位置

        XorBasis() {clear();}

        void operator=(const XorBasis &b)
        {
            for(int i=0;ix)
    {
        vector >&G=X[x.se].G;
        for(int i=sz(G)-1;~i && x.fi;--i)
        {
            type t=x.fi^G[i].fi;
            if(tG[i].fi)break;
                if(x.se>G[i].se)swap(G[i],x);
                x.fi^=G[i].fi;
            }
        }
        if(!x.fi){X[x.se].zero=x.se;return;}
        G.pb(x);
        for(int i=sz(G)-1;i && G[i].fi >&G=X[r].G;

        type res=0;
        for(int i=sz(G)-1;~i;--i)
            if(G[i].se>=l && (res^G[i].fi)>res)
                res^=G[i].fi;
        return res;
    }

    void clear()
    {
        for(int i=1;i<=n;++i)
            X[i].clear();
    }
}X;