for (int len = min(n, m); len > 0; len--) {
    for (int i = 1; i <= n - len + 1; i++) {
        for (int j = 1; j <= m - len + 1; j++) {
            long long sumA = 0, sumB = 0;
            for (int k = 0; k < len; k++) {
                sumA += a[i + k];
                sumB += b[j + k];
            }
            if (sumA == sumB) {
                cout << len << " " << i << " " << j;
                return;
            }
        }
    }
}

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

int n, m, a[1000005], b[1000005];
int preA[1000005], preB[1000005];
map<int, vector<pair<int, int>>> mp;

signed main() {
    // Input reading and prefix sum calculation
    // preA[i] = a[1] + ... + a[i]

    // Store all subarray sums of A into map
    // Key: sum, Value: list of (length, start_index)
    for (int len = 1; len <= n; len++) {
        for (int i = 1; i <= n - len + 1; i++) {
            int sum = preA[i + len - 1] - preA[i - 1];
            mp[sum].push_back({len, i});
        }
    }

    // Sort vectors in map to ensure order: max len -> min start index
    for (auto &p : mp) {
        sort(p.second.begin(), p.second.end(), [](pair<int,int> a, pair<int,int> b) {
            if (a.first != b.first) return a.first > b.first;
            return a.second < b.second;
        });
    }

    // Iterate through B's subarrays to find match
    int bestLen = 0, bestI = -1, bestJ = -1;
    for (int len = min(n, m); len > 0; len--) {
        if (len < bestLen) break; // Optimization
        for (int j = 1; j <= m - len + 1; j++) {
            int sum = preB[j + len - 1] - preB[j - 1];
            if (mp.count(sum)) {
                for (auto p : mp[sum]) {
                    if (p.first == len) {
                        // Found match with same length
                        // Since we iterate len descending, first match is best
                        cout << len << " " << p.second << " " << j;
                        return 0;
                    }
                    if (p.first < len) break; // No longer matches possible in this bucket
                }
            }
        }
    }
    cout << "0 0 0";
}

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

int n, m, a[1000005], b[1000005];
int preA[1000005], preB[1000005];
int mod = 1e9 + 7;
int c[100005];

signed main() {
    // Input reading
    c[0] = 1;
    for (int i = 1; i <= 100000; i++) {
        c[i] = (c[i-1] * 100003) % mod;
    }

    // Using hashing for sums to reduce collisions (though problem implies sums match)
    // Actually, the problem asks for sum matching. The hash in solution 1 is just for sum calculation?
    // No, solution 1 calculates: a[i] = (c[a[i]] + a[i-1]).
    // This effectively hashes the elements, but the sum of these hashes represents the subarray.
    // Wait, if we need exact sum match, we can just use prefix sums.
    // However, the provided solution 1 uses a specific hash-like structure for the array elements before summing.
    // Let's stick to the prefix sum logic but explain the complexity reduction.

    // Correct logic for O(N^2) with optimization:
    // 1. Calculate prefix sums for A and B.
    // 2. Iterate length from min(n, m) down to 1.
    // 3. For each length, use a map to store sums of A's subarrays of that length.
    // 4. Then iterate B's subarrays of that length and check.

    // Code snippet for O(N^2) approach:
    for(int len = min(n, m); len > 0; len--) {
        map<int, int> mp; // sum -> start index of A (smallest)
        for(int i = 1; i <= n - len + 1; i++) {
            int sum = preA[i + len - 1] - preA[i - 1];
            if (mp.find(sum) == mp.end()) mp[sum] = i;
        }
        for(int j = 1; j <= m - len + 1; j++) {
            int sum = preB[j + len - 1] - preB[j - 1];
            if (mp.count(sum)) {
                cout << len << " " << mp[sum] << " " << j;
                return 0;
            }
        }
    }
    cout << "0 0 0";
}