// Link : https://r...content-available-to-author-only...e.com/editorial/codeforces-round-1068-div-2
#include <bits/stdc++.h>
using namespace std;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int t;
    cin >> t;

    while (t--) {
        int n, q;
        cin >> n >> q;

        vector<long long> a(n + 1);
        vector<long long> prefix(n + 1, 0);

        for (int i = 1; i <= n; i++) {
            cin >> a[i];
            prefix[i] = prefix[i - 1] + a[i];
        }

        while (q--) {
            int l, r;
            long long x;
            cin >> l >> r >> x;

            // Step 1: Binary search for threshold position
            // Find first position in [l, r] where a[pos] < x
            int threshold = r + 1;
            int left = l, right = r;
            while (left <= right) {
                int mid = left + (right - left) / 2;
                if (a[mid] < x) {
                    threshold = mid;
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            }

            // Step 2: Count fast clears (each element >= x causes one clear)
            long long clears = threshold - l;

            // Step 3: Simulate slow zone with binary search on prefix sums
            long long current_sum = 0;
            int pos = threshold;

            while (pos <= r) {
                // Find smallest j where prefix[j] >= prefix[pos-1] + (x - current_sum)
                long long target = prefix[pos - 1] + (x - current_sum);

                int next_overflow = -1;
                left = pos;
                right = r;
                while (left <= right) {
                    int mid = left + (right - left) / 2;
                    if (prefix[mid] >= target) {
                        next_overflow = mid;
                        right = mid - 1;
                    } else {
                        left = mid + 1;
                    }
                }

                if (next_overflow == -1) {
                    // No overflow - add remaining elements to final sum
                    current_sum += prefix[r] - prefix[pos - 1];
                    break;
                } else {
                    // Clear triggered at position next_overflow
                    clears++;
                    current_sum = 0;
                    pos = next_overflow + 1;
                }
            }

            cout << clears << " " << current_sum << "\n";
        }
    }

    return 0;
}