void solve(){
    int numElements, maxSplit;
    cin>>numElements>>maxSplit;

    vector<int> elementSequence;
    elementSequence.push_back(numElements);

    int splitCount=0;
    while(elementSequence.size() < numElements)
    {
        int currentElement=elementSequence.back();
        elementSequence.erase(elementSequence.begin()+elementSequence.size()-1);
        for(int i=0;i<min(maxSplit-1,currentElement-1);i++)
        {
            elementSequence.push_back(1);
        }
        elementSequence.push_back(currentElement-maxSplit+1);
        splitCount++;
    }

    cout<<splitCount<<endl;
}

tahmid_test.cpp vaibhav2740 AbirVaiaJoss bt_fidato AryanSingh2099 brainard27 olympiad2027 kappss

void solve() {
    int n;
    cin >> n;
    string s;
    cin >> s;
    vector<int> v;
    char prev = '1';
    for (int i = 0; i < n; i++) {
        if (s[i] == '1') v.push_back(1);
        if (s[i] == '0' && prev == '1') v.push_back(0);
        prev = s[i];
    }
    int n0 = 0, n1 = 0;
    for (int i = 0; i < v.size(); i++) {
        if (v[i] == 1) n1++;
        else n0++;
    }
    if (n0 >= n1) cout << "NO" << endl;
    else cout << "YES" << endl;

def runcase():
    n = int(input())
    s = input()
    counter = [0, 0]
    
    q = int(s[0])
    counter[q] += 1
    
    for i in range(1, n):
        k = int(s[i])
        if s[i] == s[i - 1] and s[i - 1] == '0':
            continue
        counter[k] += 1
    
    if counter[1] > counter[0]:
        print("YES")
    else:
        print("NO")

def main():
    t = int(input())
    for _ in range(t):
        runcase()

if __name__ == "__main__":
    main()

#include <bits/stdc++.h>
using namespace std;
#define ll long long

void process_subsegments() {
    ll num_elements, max_sum;
    cin >> num_elements >> max_sum;
    ll elements_array[num_elements], prefix_sum_array[num_elements + 1] = {0}, dynamic_programming_array[num_elements + 3] = {0};
    
    // Read elements array
    for (ll i = 0; i < num_elements; ++i) {
        cin >> elements_array[i];
        prefix_sum_array[i + 1] = prefix_sum_array[i] + elements_array[i];
    }
    
    ll total_valid_subsegments = 0;
    
    // Process subsegments in reverse order
    for (ll i = num_elements - 1; i >= 0; --i) {
        ll target_sum = prefix_sum_array[i] + max_sum;
        
        // Find the lower bound of the target sum in the prefix sum array
        auto lower_bound_index = lower_bound(prefix_sum_array, prefix_sum_array + num_elements + 1, target_sum) - prefix_sum_array;
        
        // Calculate the number of valid subsegments
        if (lower_bound_index == num_elements + 1)
            dynamic_programming_array[i] += (num_elements - i);
        else if (target_sum == prefix_sum_array[lower_bound_index])
            dynamic_programming_array[i] += (lower_bound_index - i) + dynamic_programming_array[lower_bound_index + 1];
        else
            dynamic_programming_array[i] += (lower_bound_index - i - 1) + dynamic_programming_array[lower_bound_index];
    }
    
    // Calculate the total number of valid subsegments
    for (ll i = 0; i < num_elements + 3; ++i) {
        total_valid_subsegments += dynamic_programming_array[i];
    }
    
    cout << total_valid_subsegments << endl;
}

int main() {
    ll test_cases = 1;
    cin >> test_cases;
    
    while (test_cases--) {
        process_subsegments();
    }
    
    return 0;
}