#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#define REP(i,a,b) for(i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)

#define ll long long
#define ull unsigned ll

#define UINT_HASH_SIZE 2000000
unsigned uint_hash_n[UINT_HASH_SIZE]; int uint_hash_d[UINT_HASH_SIZE];

void uintHashClear(){
  memset(uint_hash_d,0,UINT_HASH_SIZE*sizeof(int));
}

int uintHashFunction(unsigned a){
  return (a*1007)%UINT_HASH_SIZE;
}

int uintHashGet(unsigned a){
  int i=uintHashFunction(a);
  for(;;){
    if(uint_hash_n[i]==a && uint_hash_d[i]) break;
    if(!uint_hash_d[i]) break;
    i++; if(i==UINT_HASH_SIZE) i=0;
  }
  if(uint_hash_n[i]!=a) return 0; return uint_hash_d[i];
}

void uintHashSet(unsigned a,int n){
  int i=uintHashFunction(a);
  for(;;){
    if(uint_hash_n[i]==a && uint_hash_d[i]) break;
    if(!uint_hash_d[i]) break;
    i++; if(i==UINT_HASH_SIZE) i=0;
  }
  uint_hash_n[i]=a; uint_hash_d[i]=n;
}

int uintHashIncrease(unsigned a){
  int i=uintHashFunction(a);
  for(;;){
    if(uint_hash_n[i]==a && uint_hash_d[i]) break;
    if(!uint_hash_d[i]) break;
    i++; if(i==UINT_HASH_SIZE) i=0;
  }
  uint_hash_n[i]=a; return ++uint_hash_d[i];
}



typedef struct int_matrix{
  int r,c;
  int **data;
}intMatrix;

void* newIntMatrix(intMatrix *a,int r,int c,void *WorkMemory){
  int i;
  a->r=r; a->c=c;
  a->data = (int**)WorkMemory; WorkMemory = (void*)(a->data + r);
  rep(i,r){a->data[i] = (int*)WorkMemory; WorkMemory = (void*) (a->data[i] + c);}
  return WorkMemory;
}

void intMatrixSetZero(intMatrix *a){
  int i,j;
  rep(i,a->r) rep(j,a->c) a->data[i][j]=0;
}

void intMatrixSetIdentity(intMatrix *a){
  int i,mx;
  mx=a->r; if(mx>a->c) mx=a->c;
  intMatrixSetZero(a); rep(i,mx) a->data[i][i]=1;
}

void intMatrixMultipleMod(intMatrix *a,intMatrix *b,intMatrix *res,int m){
  int i,j,k;
  intMatrixSetZero(res);
  rep(i,res->r) rep(k,b->r) if(a->data[i][k]) rep(j,res->c) {
    res->data[i][j]+=a->data[i][k]*b->data[k][j];
    if(res->data[i][j]>=m) res->data[i][j]%=m;
  }
}

void intMatrixPowerMod(intMatrix *a,intMatrix *res,int k,int m,void *WorkMemory){
  int i,j,n=a->r;
  intMatrix tmp1,tmp2;
  
  res->r=res->c=n;
  if(k==0){ intMatrixSetIdentity(res); return; }
  if(k==1){ rep(i,n)rep(j,n)res->data[i][j]=a->data[i][j]; return; }
  if(k==2){ intMatrixMultipleMod(a,a,res,m); return; }

  WorkMemory = newIntMatrix(&tmp1,n,n,WorkMemory);
  intMatrixPowerMod(a, &tmp1, k/2, m, WorkMemory);
  if(k%2==0) intMatrixMultipleMod(&tmp1,&tmp1,res,m);
  else {
    WorkMemory = newIntMatrix(&tmp2,n,n,WorkMemory);
    intMatrixMultipleMod(&tmp1,&tmp1,&tmp2,m);
    intMatrixMultipleMod(a,&tmp2,res,m);
  }
}


/* just sort */
void intSort(int d[],int s){int i=-1,j=s,k,t;if(s<=1)return;k=(d[0]+d[s-1])/2;for(;;){while(d[++i]<k);while(d[--j]>k);if(i>=j)break;t=d[i];d[i]=d[j];d[j]=t;}intSort(d,i);intSort(d+j+1,s-j-1);}

/* find the index of the first element which smaller than n */
int binarySearch(int d[],int size,int n){
  int c = size/2;
  if(size==1){if(d[0]<n) return 0; return -1;}
  if(size<=0) return -1;
  if(d[c] < n) return binarySearch(d+c,size-c,n) + c;
  return binarySearch(d,c,n);
}


int arr[1200000];
int main(){
  int T;
  void *mem = malloc(10000000);

  scanf("%d",&T);
  while(T--){
    int i, k;
    int A,B,X,Y,Z,P,C,Q;
    ll L,R;
    intMatrix mt, pw;
    void *next_mem;

    int per;
    int priod = -1;
    int first_appear[100000], first_appear_size;

    scanf("%d%d%d%d%d%d%d%d",&A,&B,&X,&Y,&Z,&P,&C,&Q);

    if(X==0 && Y==0){
      while(Q--){
        ll res = 0;
        scanf("%lld%lld",&L,&R);
        if(L==1 && L<=R){
          L++;
          if(A==C) res++;
        }
        if(L==2 && L<=R){
          L++;
          if(B==C) res++;
        }
        if(L<=R && Z==C){
          res += R-L+1;
        }
        printf("%lld\n",res);
      }
      continue;
    }

    next_mem = newIntMatrix(&mt,3,3,mem); /* generate 3*3 matrices mt and pw */
    next_mem = newIntMatrix(&pw,3,3,next_mem);
    uintHashClear();

    per = (int)pow(P, 3.0/2.0) + 2;
    
    intMatrixSetZero(&mt); /* set the matrix mt */
    mt.data[0][1] = 1;
    mt.data[2][2] = 1;
    mt.data[1][0] = Y;
    mt.data[1][1] = X;
    mt.data[1][2] = Z;

    intMatrixPowerMod(&mt, &pw, per, P, next_mem); /* pw = mt^per (mod P) */

    arr[0] = B;
    arr[1] = (B*X + A*Y + Z) % P;
    REP(i,2,per+2) arr[i] = (arr[i-1]*X + arr[i-2]*Y + Z)%P;

    rep(i,per){
      unsigned hs = arr[i]*P + arr[i+1];
      k = uintHashGet(hs) - 1;
      if(k >= 0){ /* if the hash contains hs */
        priod = i;
        break;
      }
      uintHashSet(hs, i+1);
    }

    if(priod == -1){ // calculate priod
      ll add = 0;
      int SA = arr[0], SB = arr[1], NA, NB;
      for(;;){
        k = uintHashGet(SA*P + SB) - 1;
        if(add > 0 && k >= 0){
          priod = add - k;
          break;
        }
        add += per;
        NA = (SA * pw.data[0][0] + SB * pw.data[0][1] + pw.data[0][2]) % P;
        NB = (SA * pw.data[1][0] + SB * pw.data[1][1] + pw.data[1][2]) % P;
        SA = NA; SB = NB;
      }
    }

/*    printf("P = %d, Q = %d\n",P,Q);
    printf("A = %d, B = %d\n",A,B);
    printf("X = %d, Y = %d, Z = %d\n",X,Y,Z);
    printf("priod %d\n",priod);*/

    first_appear_size = 0;
    rep(i,P){ // calculate the position of the fitst appearance of (C, i, 1)
      ll add = 0;
      int SA = C, SB = i, NA, NB;
      for(;;){
        k = uintHashGet(SA*P + SB) - 1;
        if(k >= 0){
          first_appear[first_appear_size] = (priod - add + k) % priod;
          first_appear_size++;
          break;
        }
        add += per;
        if(add > priod) break;
        
        NA = (SA * pw.data[0][0] + SB * pw.data[0][1] + pw.data[0][2]) % P;
        NB = (SA * pw.data[1][0] + SB * pw.data[1][1] + pw.data[1][2]) % P;
        SA = NA; SB = NB;
      }
    }

    intSort(first_appear, first_appear_size);

    while(Q--){
      ll res = 0;
      ll s, t;
      
      scanf("%lld%lld",&L,&R);
      L--;

      if(L==0){
        if(C==A) res++;
        R--;
      } else {
        L--; R--;
      }

      s = binarySearch(first_appear, first_appear_size, L % priod) + 1;
      t = binarySearch(first_appear, first_appear_size, R % priod);

      res += t-s+1;
      res += first_appear_size * (R/priod - L/priod);
      
      printf("%lld\n",res);
    }

  }

  return 0;
}