using System;

/*
 * ================================================================================
 * The code reads the input, computes partial answer and outputs the answer.
 * You only need to fill the indicated part in DivideAndConquer.CountOverSplit().
 * ================================================================================
 */

namespace Stocks
{
    class Program
    {
        /*
         *  Parse and solve all the test cases.
         */
        static void Main(string[] args)
        {
            int numTestCases = Int32.Parse(Console.ReadLine());
            for(int i=0; i<numTestCases; i++)
                ParseAndSolve();
        }

        /*
         *  Parse and solve a test case.
         */
        static void ParseAndSolve()
        {
            int numNumbers = Int32.Parse(Console.ReadLine());
            string[] subStr = Console.ReadLine().Split(' ');
            
            int[] input = new int[numNumbers];
            for(int i=0; i<numNumbers; i++)
                input[i] = Int32.Parse(subStr[i]);
            
            int lb = Int32.Parse(Console.ReadLine());
            int ub = Int32.Parse(Console.ReadLine());
            
            DivideAndConquer.Solve(input, lb, ub);
        }
    }

    class DivideAndConquer
    {
        
        /*
         *  Compute the answer and output the result.
         */
        public static void Solve(int[] input, int lb, int ub)
        {
            int len = input.Length;
            int[] buf = new int[len]; // Will explain this variable later in SolveRecursively().
            int ans = SolveRecursively(input, 0, len, lb, ub, buf);
            Console.WriteLine(ans);
        }

        /*
         *  Compute the answer of the subsequence starting from index s (inclusively) and ending at index e (exclusively).
         *  input: the whole input sequence of numbers.
         *  s: the index indicating the start (inclusively) of the subsequence.
         *  e: the index indicating the end (exclusively) of the subsequence.
         *  lb: the lower bound of the sum (ell in the document).
         *  ub: the upper bound of the sum (u in the document).
         *  prefixSum: a memory buffer for computing prefix sum. The prefix sum is computed 'in' this subroutine. The memory allocation for prefixSum is done only once in Solve() for better runtime performance.
         */
        static int SolveRecursively(int[] input, int s, int e, int lb, int ub, int[] prefixSum)
        {
            // Check if the pair (s, e) is valid.
            if(e <= s)
                return 0;
            
            // Compute the answer of the subsequence directly if the length of the subsequence is small enough.
            if(e == s + 1)
            {
                int a = input[s];
                if(lb <= a && a <= ub)
                    return 1;
                return 0;
            }

            int ans = 0;
            int m = (s + e) / 2; // The index indicating the middle of the subsequence.

            // Compute the answer for the subsequence starting from s and ending with m and the subsequence starting from m and ending with e respectively.
            ans += SolveRecursively(input, s, m, lb, ub, prefixSum);
            ans += SolveRecursively(input, m, e, lb, ub, prefixSum);

            // Now you already have the answers of the subsequence from s to m and the subsequence from m to e.
            // The rest is to find the additional answers of the contiguous subsequences that go across m (and these subsequences are fully contained in the subsequence from s to e).
            // You will need the help of prefix sum.

            // Compute the prefix sum from s to e and store the prefix sum to prefixSum[s..e].
            int t; // A variable for storing partial prefix sum.
            t = input[s];
            prefixSum[s] = t;
            for(int i=s+1; i<e; i++)
            {
                prefixSum[i] = t + input[i];
                t = prefixSum[i];
            }

            // In addition to the prefix sum, you will also need a sorted prefix sum for the subsequence from m to e.

            // Sort the prefix sum for the subsequence from m to e.
            int len2 = e - m;
            Array.Sort(prefixSum, m, len2);

            // With the help of the results stored in prefixSum, please fill the rest of the code in CountOverSplit().
            ans += CountOverSplit(prefixSum, s, m, e, lb, ub);

            return ans;
        }
	static int getSum(int[] prefixSum, int s, int begin, int end){
		if(begin-1<s)return prefixSum[end];
		else return prefixSum[end]-prefixSum[begin-1];
	}

        /*
         *  Compute the answers of the contiguous subsequences that go across m (and these subsequences are fully contained in the subsequence from s to e).
         *  prefixSum: the prefix sum (in a certain order) of the input in SolveRecursively(). prefixSum can be treated as two parts. The first part, prefixSum[s..m], is the prefix sum of input[s..m]. The second part, prefixSum[m..e], is the prefix sum sorted non-decreasingly of input[m..e].
         *  s: the index indicating the start (inclusively) of the subsequence.
         *  m: the index indicating the middle of the subsequence. It is excluded in the first part of prefixSum and is included in the second part of prefixSum.
         *  e: the index indicating the end (exclusively) of the subsequence.
         *  lb: the lower bound of the sum (ell in the document).
         *  ub: the upper bound of the sum (u in the document).
         */
        static int CountOverSplit(int[] prefixSum, int s, int m, int e, int lb, int ub)
        {
            int ans = 0;

	    //Console.Write("prefixSum:");
	    //foreach(int i in prefixSum){
	    //        Console.Write(i);
	    //        Console.Write(",");
	    //}
	    //Console.WriteLine("");


            /* ==================== Your code starts here ==================== */
	    for(int i =s;i<m;i++){
	            int rightmost=m;
		    
		    if(getSum(prefixSum,s,i,e-1)<=ub)
			    rightmost = e-1;
		    else if(getSum(prefixSum,s,i,m)>ub)
			    continue;
		    else
			    //Find the rightmost j such that prefixSum[j]-prefixSum[i-1]<=ub
			    for(int b=e-1; rightmost+1<b;)
				if(getSum(prefixSum,s,i,(rightmost+b)/2)<=ub)
					rightmost=(rightmost+b)/2;
				else
					b=(rightmost+b)/2;
		   
		    int leftmost=rightmost;
		    if(getSum(prefixSum,s,i,m)>=lb)
			    leftmost = m;
		    else if(getSum(prefixSum,s,i,rightmost)<lb)
			    continue;
		    else
			    //Find the leftmost j such that prefixSum[j]-prefixSum[i-1]>=lb
			    for( int a=m; a+1<leftmost;)
				if(getSum(prefixSum,s,i,(a+leftmost)/2) >= lb)
					leftmost=(a+leftmost)/2;
				else
					a=(a+leftmost)/2;
		    ans+= rightmost-leftmost+1;
	    }
            

            /* ==================== Your code ends here ==================== */
            
            return ans;
        }
    }
}