#include <iostream>
#include <vector>
using namespace std;

// Parameters for computation
const long long MODULO = 998244353;
const int MAX_SUM = 500000;

// Efficient power calculation with modular arithmetic
long long power_mod(long long base, long long exponent) {
    long long result = 1;
    base %= MODULO;
    while (exponent > 0) {
        if (exponent & 1)
            result = (result * base) % MODULO;
        base = (base * base) % MODULO;
        exponent >>= 1;
    }
    return result;
}

// Storage for precomputed values
vector<long long> factorial, inverse_factorial;

// Initialize mathematical tables needed for calculations
void initialize_tables() {
    factorial.resize(MAX_SUM + 1);
    inverse_factorial.resize(MAX_SUM + 1);
    
    factorial[0] = 1;
    for (int i = 1; i <= MAX_SUM; i++) {
        factorial[i] = (factorial[i-1] * i) % MODULO;
    }
    
    // Calculate inverses using Fermat's little theorem
    inverse_factorial[MAX_SUM] = power_mod(factorial[MAX_SUM], MODULO - 2);
    for (int i = MAX_SUM; i >= 1; i--) {
        inverse_factorial[i-1] = (inverse_factorial[i] * i) % MODULO;
    }
}

// Dynamic programming solution for counting valid combinations
long long count_combinations(const vector<int>& elements, int target_sum) {
    vector<long long> memo(target_sum + 1, 0);
    memo[0] = 1;
    
    for (int val : elements) {
        for (int j = target_sum; j >= val; j--) {
            memo[j] = (memo[j] + memo[j - val]) % MODULO;
        }
    }
    
    return memo[target_sum];
}

int main() {
    initialize_tables();
    
    int test_cases;
    cin >> test_cases;
    
    while (test_cases--) {
        vector<int> counts(26);
        long long total_sum = 0;
        
        for (int i = 0; i < 26; i++) {
            cin >> counts[i];
            total_sum += counts[i];
        }
        
        int left_half = (total_sum + 1) / 2;
        int right_half = total_sum / 2;
        
        // Check initial feasibility
        bool feasible = true;
        for (int i = 0; i < 26; i++) {
            if (counts[i] > left_half) {
                feasible = false;
                break;
            }
        }
        
        if (!feasible) {
            cout << "0" << endl;
            continue;
        }
        
        // Separate required elements from optional ones
        int required_sum = 0;
        vector<int> optional;
        
        for (int i = 0; i < 26; i++) {
            if (counts[i] == 0) continue;
            
            if (counts[i] > right_half) {
                required_sum += counts[i];
            } else {
                optional.push_back(counts[i]);
            }
        }
        
        int remaining = left_half - required_sum;
        
        if (remaining < 0) {
            cout << "0" << endl;
            continue;
        }
        
        // Check if we have enough optional elements
        int available = 0;
        for (int val : optional) {
            available += val;
        }
        
        if (remaining > available) {
            cout << "0" << endl;
            continue;
        }
        
        // Count valid subset combinations
        long long subset_ways = count_combinations(optional, remaining);
        
        // Calculate total arrangement ways
        long long arrangement_ways = (factorial[left_half] * factorial[right_half]) % MODULO;
        for (int i = 0; i < 26; i++) {
            arrangement_ways = (arrangement_ways * inverse_factorial[counts[i]]) % MODULO;
        }
        
        long long answer = (subset_ways * arrangement_ways) % MODULO;
        cout << answer << endl;
    }
    
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

void processQuery() {
    int length;
    cin >> length;
    
    vector<int> mapping(length + 1);
    for (int i = 1; i <= length; i++){
        cin >> mapping[i];
    }
    
    // Sequence of positions to be zeroed out
    vector<int> sequence(length + 1);
    for (int i = 1; i <= length; i++){
        cin >> sequence[i];
    }
    
    // Identify connected components in the permutation
    vector<int> group(length + 1, 0);
    vector<int> groupLength;
    int groupCount = 0;
    
    for (int i = 1; i <= length; i++){
        if (group[i] != 0) continue;
        groupCount++;
        int current = i;
        int elements = 0;
        while (group[current] == 0) {
            group[current] = groupCount;
            elements++;
            current = mapping[current];
        }
        groupLength.push_back(elements);
    }
    
    vector<bool> modified(groupCount + 1, false);
    long long total = 0;
    
    for (int i = 1; i <= length; i++){
        int position = sequence[i];
        int componentId = group[position];
        if (!modified[componentId]) {
            modified[componentId] = true;
            total += groupLength[componentId - 1];
        }
        cout << total << " ";
    }
    cout << "\n";
}
 
int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int testCases;
    cin >> testCases;
    while(testCases--){
        processQuery();
    }
    return 0;
}

#include <stdio.h>

// Altered function name and parameter names while keeping the functionality
int find_position(long long sequence[], int size, long long threshold) {
    int start = 0, end = size;
    while (start < end) {
        int middle = start + (end - start) / 2;
        if (sequence[middle] <= threshold)
            start = middle + 1;
        else
            end = middle;
    }
    return start;
}

int main(void) {
    int test_cases;
    if (scanf("%d", &test_cases) != 1) return 1;
    
    while(test_cases--) {
        int length, copies;
        long long target;
        if (scanf("%d %d %lld", &length, &copies, &target) != 3) return 1;
        
        int idx;
        int sequence[length];
        for (idx = 0; idx < length; idx++) {
            scanf("%d", &sequence[idx]);
        }
        
        // Using different variable names for the prefix sums
        long long cumulative[length];
        cumulative[0] = 0;
        for (idx = 1; idx < length; idx++) {
            cumulative[idx] = cumulative[idx-1] + sequence[idx-1];
        }
        
        long long total_single = cumulative[length-1] + sequence[length-1];
        
        // Changed the early termination check logic (equivalent but restructured)
        if (total_single * copies < target) {
            printf("0\n");
            continue;
        }
        
        long long remainder = copies * total_single - target;
        long long result = 0;
        
        // Rewritten the loop with different variable names
        for (int iter = 0; iter < copies; iter++) {
            long long current_limit = remainder - (long long)iter * total_single;
            if (current_limit < 0) continue;
            
            int count = find_position(cumulative, length, current_limit);
            result += count;
        }
        
        printf("%lld\n", result);
    }
    return 0;
}