description: British mathematician John Littlewood once said about Indian mathematician Srinivasa Ramanujan that "every positive integer was one of his personal friends."
  
  It turns out that positive integers can also be friends with each other! You are given an array a of distinct positive integers. 
  
  Define a subarray a_i, a_{i+1}, …, a_j to be a friend group if and only if there exists an integer m ≥ 2 such that a_i mod m = a_{i+1} mod m = … = a_j mod m, where x mod y denotes the remainder when x is divided by y.
  
  Your friend Gregor wants to know the size of the largest friend group in a.
  
  Input
  
  Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 2⋅ 10^4). 
  
  Each test case begins with a line containing the integer n (1 ≤ n ≤ 2 ⋅ 10^5), the size of the array a.
  
  The next line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ {10}^{18}), representing the contents of the array a. It is guaranteed that all the numbers in a are distinct.
  
  It is guaranteed that the sum of n over all test cases is less than 2⋅ 10^5.
  
  Output
  
  Your output should consist of t lines. Each line should consist of a single integer, the size of the largest friend group in a.
  
  Example
  
  Input
  
  
  4
  5
  1 5 2 4 6
  4
  8 2 5 10
  2
  1000 2000
  8
  465 55 3 54 234 12 45 78
  
  
  Output
  
  
  3
  3
  2
  6
  
  Note
  
  In the first test case, the array is [1,5,2,4,6]. The largest friend group is [2,4,6], since all those numbers are congruent to 0 modulo 2, so m=2.
  
  In the second test case, the array is [8,2,5,10]. The largest friend group is [8,2,5], since all those numbers are congruent to 2 modulo 3, so m=3.
  
  In the third case, the largest friend group is [1000,2000]. There are clearly many possible values of m that work.
solution: //Some of the methods are copied from GeeksforGeeks Website  
  import java.util.*;
  import java.lang.*;
  import java.io.*;
  public class Main
  { 
    static  Reader sc=new Reader();
    // static FastReader sc=new FastReader(System.in);
    
    static int max_n=(int)2e5+5;
    static int max_log=(int)(Math.log(max_n)/Math.log(2));
    static long st[][]=new long[max_n][max_log+1];
    static int log[]=new int[max_n];
    static int n;
    static long a[];
    
   
    static void sparse_table()
     {
        for(int i=0;i<n;i++)
          {
             st[i][0]=a[i];
          }
       for(int j=1;j<=max_log;j++)
          {
             for(int i=0;i+(1<<j)<=n;i++)
               {
                  st[i][j]=gcd(st[i][j-1],st[i+(1<<(j-1))][j-1]);
               }
          }
     }
  
   static long gcd_query(int l,int r)
    {
      long gcd= 0;
      for (int j=max_log;j>=0;j--) 
      {
        if ((1 << j) <= r - l + 1) 
        {
          gcd=gcd(gcd,st[l][j]);
          l += 1 << j;
         }
       }
      return gcd;
    }
   
   public static void main (String[] args) throws java.lang.Exception
     {
  	//try{
  	  
  		  int t =  sc.nextInt();
  		  while(t-->0)
  		    { 
  		       n=sc.nextInt();
  		       long b[]=new long[n];
  		       for(int i=0;i<n;i++)
  		         {
  		           b[i]=sc.nextLong();
  		         }
  		       if(n==1)
  		        {
  		           out.println(n);
  		           continue;
  		        }
  		       n--;
  		       a=new long[n];
  		       for(int i=0;i<n;i++)
  		         a[i]=Math.abs(b[i+1]-b[i]);
  		       
  		       sparse_table();
  		       int longest_seg=0;
  		       for(int right=0;right<n;right++)
  		         {
  		            int l=0;
  		            int r=right;
  		            int left=r;
  		            while(l<=r)
  		              {
  		                 int m=l+(r-l)/2;
  		                 if(gcd_query(m,right)!=1)
  		                   {
  		                      r=m-1;
  		                      left=Math.min(left,r);
  		                   }
  		                else
  		                   {
  		                      l=m+1;
  		                   }
  		              }
  		            longest_seg=Math.max(longest_seg,right-left+1);
  		         }
  		     
  		       out.println(longest_seg);
  		    }
  	     out.flush();
  	     out.close();
  // 	   }     
  // 	catch(Exception e)
  // 		 {}
  	}
   
   /*
     ...SOLUTION ENDS HERE...........SOLUTION ENDS HERE...
   */
   
  static void flag(boolean flag)
     {
         out.println(flag ? "YES" : "NO");
         out.flush();
     }
     
   /*                     
      Map<Long,Long> map=new HashMap<>();
               for(int i=0;i<n;i++)
                 {
                    if(!map.containsKey(a[i]))
                     map.put(a[i],1);
                   else
                     map.replace(a[i],map.get(a[i])+1);
                 }
       
      Set<Map.Entry<Long,Long>> hmap=map.entrySet();
               for(Map.Entry<Long,Long> data : hmap)
                 {
            
                 }
         
     Iterator<Integer> it = set.iterator();
            while(it.hasNext()) 
             { 
              int x=it.next();
             }
     */
  
  static void print(int a[])
    {
       int n=a.length;
       for(int i=0;i<n;i++)
         {
            out.print(a[i]+" ");
         }
       out.println();
       out.flush();
    }
  static void print(long a[])
    {
       int n=a.length;
       for(int i=0;i<n;i++)
         {
            out.print(a[i]+" ");
         }
       out.println();
       out.flush();
    } 
  static void print_int(ArrayList<Integer> al)
    {
       int si=al.size();
       for(int i=0;i<si;i++)
         {
            out.print(al.get(i)+" ");
         }
       out.println();
       out.flush();
    }
  static void print_long(ArrayList<Long> al)
    {
       int si=al.size();
       for(int i=0;i<si;i++)
         {
            out.print(al.get(i)+" ");
         }
       out.println();
       out.flush();
    }
    
  static int LowerBound(int a[], int x) 
   { // x is the target value or key
    int l=-1,r=a.length;
    while(l+1<r) {
      int m=(l+r)>>>1;
      if(a[m]>=x) r=m;
      else l=m;
    }
    return r;
  }
  
   static int UpperBound(int a[], int x)
    {// x is the key or target value
      int l=-1,r=a.length;
      while(l+1<r) {
         int m=(l+r)>>>1;
         if(a[m]<=x) l=m;
         else r=m;
      }
      return l+1;
   }
  static class Graph
    {
          int v;
          ArrayList<Integer> list[];
          Graph(int v)
          {
              this.v=v;
              list=new ArrayList[v+1];
              for(int i=1;i<=v;i++)
                  list[i]=new ArrayList<Integer>();
          }
          void addEdge(int a, int b)
          {
              this.list[a].add(b);
          }
      }
  static void DFS(Graph g, boolean[] visited, int u)
  	{
          visited[u]=true;
          int v=0;
          for(int i=0;i<g.list[u].size();i++)
          {
              v=g.list[u].get(i);
              if(!visited[v])
                 DFS(g,visited,v);
          }
    } 
    
  // static class Pair
  //    {
  //       int x,y;
  //       Pair(int x,int y)
  //        {
  //           this.x=x;
  //           this.y=y;
  //        }
  //    }
     
  static long sum_array(int a[])
   {
      int n=a.length;
      long sum=0;
      for(int i=0;i<n;i++)
       sum+=a[i];
      return sum;
   }
  static long sum_array(long a[])
   {
      int n=a.length;
      long sum=0;
      for(int i=0;i<n;i++)
       sum+=a[i];
      return sum;
   }
  
   static void sort(int[] a) 
     {
  		ArrayList<Integer> l=new ArrayList<>();
  		for (int i:a) l.add(i);
  		Collections.sort(l);
  		for (int i=0; i<a.length; i++) a[i]=l.get(i);
  	}
  static void sort(long[] a) 
     {
  		ArrayList<Long> l=new ArrayList<>();
  		for (long i:a) l.add(i);
  		Collections.sort(l);
  		for (int i=0; i<a.length; i++) a[i]=l.get(i);
  	}
  
  static void reverse_array(int a[])
   {
      int n=a.length;
      int i,t; 
      for (i = 0; i < n / 2; i++) { 
              t = a[i]; 
              a[i] = a[n - i - 1]; 
              a[n - i - 1] = t; 
          } 
   }
  static void reverse_array(long a[])
   {
      int n=a.length;
      int i; long t; 
      for (i = 0; i < n / 2; i++) { 
              t = a[i]; 
              a[i] = a[n - i - 1]; 
              a[n - i - 1] = t; 
          } 
   }
   static long modInverse(long a, long m)
  	    {
  	        long g = gcd(a, m);
  	       
  	          return   power(a, m - 2, m);
  	        
  	    }
  static long power(long x, long y, long m)
  	    {
  	        if (y == 0)
  	            return 1;
  	        long p = power(x, y / 2, m) % m;
  	        p = (int)((p * (long)p) % m);
  	        if (y % 2 == 0)
  	            return p;
  	        else
  	            return (int)((x * (long)p) % m);
  	    }
  static long gcd(long a, long b) 
      { 
          if (a == 0) 
              return b; 
            
          return gcd(b%a, a); 
      } 
  static int gcd(int a, int b) 
      { 
          if (a == 0) 
              return b; 
            
          return gcd(b%a, a); 
      } 
  
     static class FastReader{
   
          byte[] buf = new byte[2048];
          int index, total;
          InputStream in;
   
          FastReader(InputStream is) {
              in = is;
          }
   
          int scan() throws IOException {
              if (index >= total) {
                  index = 0;
                  total = in.read(buf);
                  if (total <= 0) {
                      return -1;
                  }
              }
              return buf[index++];
          }
   
          String next() throws IOException {
              int c;
              for (c = scan(); c <= 32; c = scan());
              StringBuilder sb = new StringBuilder();
              for (; c > 32; c = scan()) {
                  sb.append((char) c);
              }
              return sb.toString();
          }
   
          int nextInt() throws IOException {
              int c, val = 0;
              for (c = scan(); c <= 32; c = scan());
              boolean neg = c == '-';
              if (c == '-' || c == '+') {
                  c = scan();
              }
              for (; c >= '0' && c <= '9'; c = scan()) {
                  val = (val << 3) + (val << 1) + (c & 15);
              }
              return neg ? -val : val;
          }
   
          long nextLong() throws IOException {
              int c;
              long val = 0;
              for (c = scan(); c <= 32; c = scan());
              boolean neg = c == '-';
              if (c == '-' || c == '+') {
                  c = scan();
              }
              for (; c >= '0' && c <= '9'; c = scan()) {
                  val = (val << 3) + (val << 1) + (c & 15);
              }
              return neg ? -val : val;
          }
      }
     
      static class Reader 
      { 
          final private int BUFFER_SIZE = 1 << 16; 
          private DataInputStream din; 
          private byte[] buffer; 
          private int bufferPointer, bytesRead; 
    
          public Reader() 
          { 
              din = new DataInputStream(System.in); 
              buffer = new byte[BUFFER_SIZE]; 
              bufferPointer = bytesRead = 0; 
          } 
    
          public Reader(String file_name) throws IOException 
          { 
              din = new DataInputStream(new FileInputStream(file_name)); 
              buffer = new byte[BUFFER_SIZE]; 
              bufferPointer = bytesRead = 0; 
          } 
    
          public String readLine() throws IOException 
          { 
              byte[] buf = new byte[64]; // line length 
              int cnt = 0, c; 
              while ((c = read()) != -1) 
              { 
                  if (c == '\n') 
                      break; 
                  buf[cnt++] = (byte) c; 
              } 
              return new String(buf, 0, cnt); 
          } 
    
          public int nextInt() throws IOException 
          { 
              int ret = 0; 
              byte c = read(); 
              while (c <= ' ') 
                  c = read(); 
              boolean neg = (c == '-'); 
              if (neg) 
                  c = read(); 
              do
              { 
                  ret = ret * 10 + c - '0'; 
              }  while ((c = read()) >= '0' && c <= '9'); 
    
              if (neg) 
                  return -ret; 
              return ret; 
          } 
    
          public long nextLong() throws IOException 
          { 
              long ret = 0; 
              byte c = read(); 
              while (c <= ' ') 
                  c = read(); 
              boolean neg = (c == '-'); 
              if (neg) 
                  c = read(); 
              do { 
                  ret = ret * 10 + c - '0'; 
              } 
              while ((c = read()) >= '0' && c <= '9'); 
              if (neg) 
                  return -ret; 
              return ret; 
          } 
    
          public double nextDouble() throws IOException 
          { 
              double ret = 0, div = 1; 
              byte c = read(); 
              while (c <= ' ') 
                  c = read(); 
              boolean neg = (c == '-'); 
              if (neg) 
                  c = read(); 
    
              do { 
                  ret = ret * 10 + c - '0'; 
              } 
              while ((c = read()) >= '0' && c <= '9'); 
    
              if (c == '.') 
              { 
                  while ((c = read()) >= '0' && c <= '9') 
                  { 
                      ret += (c - '0') / (div *= 10); 
                  } 
              } 
    
              if (neg) 
                  return -ret; 
              return ret; 
          } 
    
          private void fillBuffer() throws IOException 
          { 
              bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
              if (bytesRead == -1) 
                  buffer[0] = -1; 
          } 
    
          private byte read() throws IOException 
          { 
              if (bufferPointer == bytesRead) 
                  fillBuffer(); 
              return buffer[bufferPointer++]; 
          } 
    
          public void close() throws IOException 
          { 
              if (din == null) 
                  return; 
              din.close(); 
          } 
      }
    static  PrintWriter out=new PrintWriter(System.out);
    static int int_max=Integer.MAX_VALUE;
    static int int_min=Integer.MIN_VALUE;
    static long long_max=Long.MAX_VALUE;
    static long long_min=Long.MIN_VALUE;
  }
  // Thank You !