struct segTree{
    ll size;
    vector<ll>tree;
    vector<ll>lazy;

    void init(ll n){
        tree.clear();
        size =1;
        while(size<n){
            size*=2;
        }
        tree.assign(2*size , 0);
        lazy.assign(2*size , -1);
    }

    //Node x : [lx rx] -->answer for this range

    void update(ll x ,ll lx ,ll rx , ll q_lx ,ll q_rx){
        if(q_lx <= lx && rx<=q_rx){
            if(lazy[x]==-1) lazy[x] = 1;
            else lazy[x]++;

            if(lazy[x]&1){
                tree[x] = (rx-lx+1) - tree[x];
            }

            if(rx!=lx){
                //push_downward
                if(lazy[2*x]!=-1) lazy[2*x] += lazy[x];
                else lazy[2*x] = lazy[x];
                if(lazy[2*x+1]!=-1) lazy[2*x+1] += lazy[x];
                else lazy[2*x+1] = lazy[x];
            }
            lazy[x] = -1;
            return;
        }

        if(q_lx > rx || q_rx < lx) return;

        if(lazy[x]!=-1){
            //push the information that you toggle your bits
            if(lazy[2*x]!=-1) lazy[2*x] += lazy[x];
            else lazy[2*x] = lazy[x];
            if(lazy[2*x+1]!=-1) lazy[2*x+1] += lazy[x];
            else lazy[2*x+1] = lazy[x];
            lazy[x] = -1;
        }

        ll mid = (lx +rx)>>1;
        update(2*x , lx , mid , q_lx , q_rx );
        update(2*x+1 , mid+1 , rx , q_lx , q_rx );
        tree[x] = tree[2*x] + tree[2*x+1];
    }

    void update(ll q_lx , ll q_rx){
        update(1 , 0 , size-1 , q_lx , q_rx);
    }

    ll query(ll x ,ll lx ,ll rx , ll q_lx , ll q_rx){
        if(q_lx <= lx && rx<=q_rx){
            if(lazy[x]!=-1 && lazy[x]&1){
                tree[x] = (rx-lx+1) - tree[x];
            }
            if(rx!=lx){
                //push_downward
                if(lazy[2*x]!=-1) lazy[2*x] += lazy[x];
                else lazy[2*x] = lazy[x];
                if(lazy[2*x+1]!=-1) lazy[2*x+1] += lazy[x];
                else lazy[2*x+1] = lazy[x];
            }
            lazy[x] = -1;
            return tree[x];
        }

        if(q_lx > rx || q_rx < lx) return 0;

        if(lazy[x]!=-1){
            //push the information that you toggle your bits
            if(lazy[2*x]!=-1) lazy[2*x] += lazy[x];
            else lazy[2*x] = lazy[x];
            if(lazy[2*x+1]!=-1) lazy[2*x+1] += lazy[x];
            else lazy[2*x+1] = lazy[x];
            lazy[x] = -1;
        }

        ll mid = (lx +rx)>>1;

        return query(2*x , lx , mid , q_lx , q_rx ) +
                 query(2*x+1 , mid+1 , rx , q_lx , q_rx );

    }

    ll query(ll q_lx , ll q_rx){
        return query(1 , 0 , size-1 , q_lx , q_rx);
    }

};

vector<int> binaryQueries(int n, vector<int> &a, int q, vector<vector<int>> &queries) {
    //[l ,r ,x]
    //bitwise or we want to find
    //seg tree with an array of 30

    vector<segTree>st(31);
    for(ll i=0;i<31;i++){
        st[i].init(n+1);
        for(int j=0;j<n;j++){
            if(a[j]&(1ll<<i)){
                st[i].tree[st[i].size+j] = 1;
            }
        }

        for(int j= st[i].size-1;j>=1;j--){
            st[i].tree[j] = st[i].tree[2*j] + st[i].tree[2*j + 1];
        }
    }

    //check for segTree

    vector<int>Ans;
    ll ind =0;
    for(auto it : queries){
        ll l, r , x;
        l = it[0];
        r = it[1];
        x = it[2];

        for(ll j=0;j<31;j++){
            if(x&(1ll<<j)){
                st[j].update(l ,r);
            }
        }

        ll ans =0;
        for(ll j=0;j<31;j++){
            if(st[j].query(l ,r)){
                ans += (1ll<<j);
            }
        }
        Ans.push_back(ans);
    }
    return Ans;
}