#include <bits/stdc++.h>

 #define ll long long

 #define ull unsigned long long

 #define st first

 #define nd second

 #define pii pair<int, int>

 #define pil pair<int, ll>

 #define pli pair<ll, int>

 #define pll pair<ll, ll>

 #define tiii tuple<int, int, int>

 #define pw(x) ((1LL)<<(x))

 #define lson l, m, rt<<1

 #define rson m+1, r, rt<<1|1

 #define FIN freopen("A.in","r",stdin);

 #define FOUT freopen("A.out","w",stdout);

 using namespace std;

 /***********/

 template <class T>

 bool scan (T &ret) {

     char c;

     int sgn;

     if (c = getchar(), c == EOF) return ; //EOF

     while (c != '-' && (c < '' || c > '') ) c = getchar();

     sgn = (c == '-') ? - : ;

     ret = (c == '-') ?  : (c - '');

     while (c = getchar(), c >= '' && c <= '') ret = ret *  + (c - '');

     ret *= sgn;

     return ;

 }

 template<typename N,typename PN>inline N flo(N a,PN b){return a>=?a/b:-((-a-)/b)-;}

 template<typename N,typename PN>inline N cei(N a,PN b){return a>?(a-)/b+:-(-a/b);}

 template<typename T>inline int sgn(T a) {return a>?:(a<?-:);}

 template <class T1, class T2>

 bool gmax(T1 &a, const T2 &b) { return a < b? a = b, :;}

 template <class T1, class T2>

 bool gmin(T1 &a, const T2 &b) { return a > b? a = b, :;}

 template <class T> inline T lowbit(T x) {return x&(-x);}

 template<class T1, class T2>

 ostream& operator <<(ostream &out, pair<T1, T2> p) {

     return out << "(" << p.st << ", " << p.nd << ")";

 }

 template<class A, class B, class C>

 ostream& operator <<(ostream &out, tuple<A, B, C> t) {

     return out << "(" << get<>(t) << ", " << get<>(t) << ", " << get<>(t) << ")";

 }

 template<class T>

 ostream& operator <<(ostream &out, vector<T> vec) {

     out << "("; for(auto &x: vec) out << x << ", "; return out << ")";

 }

 void testTle(int &a){

     while() a = a*(long long)a%;

 }

 const int inf = 0x3f3f3f3f;

 const long long INF = 1e17;

 const long long mod = ;

 const double eps = 1e-;

 const int N = 1e5+;

 /***********/

 int a[N], X;

 struct Tire{

     int tot, node[N][], val[N], dp[N];

     int newnode(){

         ++tot;

         node[tot][] = node[tot][] = val[tot] = ;

         dp[tot] = -1e9;

         return tot;

     }

     void init(){

         tot = ;

         newnode();

     }

     void pushup(int rt){

         val[rt] = ;

         dp[rt] = -1e9;

         if(node[rt][]&&val[ node[rt][] ]) {

             gmax(dp[rt], dp[ node[rt][] ]);

             val[rt] += val[ node[rt][] ];

         }

         if(node[rt][]&&val[ node[rt][] ]) {

             gmax(dp[rt], dp[ node[rt][] ]);

             val[rt] += val[ node[rt][] ];

         }

     }

     void update(int x, int d, int v, int now = , int dep = ){

         if(dep == -){

             val[now] += d;

             if(val[now]) gmax(dp[now], v);

             else dp[now] = -1e9;

             return ;

         }

         int t = &(x>>dep);

         if(!node[now][t]) node[now][t] = newnode();

         update(x, d, v, node[now][t], dep-);

         pushup(now);

     }

     int query(int x, int now = , int dep = ){

         if(dep == -) return dp[now];

         int t1 = &(X>>dep), t2 = &(x>>dep);

         int ret = -1e9;

         if(t1){

             if(node[now][t2]) gmax(ret, dp[ node[now][t2] ]);

             if(node[now][t2^]) gmax(ret, query(x, node[now][t2^], dep-));

         }

         else if(node[now][t2]) gmax(ret, query(x, node[now][t2], dep-));

         return ret;

     }

 }T;

 int f[N];

 int main(){

     int t; scanf("%d", &t);

     while(t--){

         int n, L, p, q, i;

         scanf("%d%d%d", &n, &X, &L);

         scanf("%d%d%d", a+, &p, &q);

         for(i = ; i <= n; i++)

             a[i] = (a[i-]*(ll)p+q)%268435456LL;

         for(int i = ; i <= n; i++)

             a[i] = a[i]^a[i-];

         T.init();

         T.update(a[], , f[]);

         for(i = ; i <= n&&i <= L; i++){

             f[i] = T.query(a[i])+;

             T.update(a[i], , f[i]);

         }

         for( ; i <= n; i++){

             T.update(a[i-L-], -, f[i-L-]);

             f[i] = T.query(a[i])+;

             T.update(a[i], , f[i]);

         }

         printf("%d\n", max(f[n], ));

     }

     return ;

 }