We'll call a sequence of integers a good *k*-*d* sequence if we can add to it at most *k* numbers in such a way that after the sorting the sequence will be an arithmetic progression with difference *d*.

You got hold of some sequence *a*, consisting of *n* integers. Your task is to find its longest contiguous subsegment, such that it is a good *k*-*d* sequence.
The first line contains three space-separated integers *n*, *k*, *d* (1 ≤ *n* ≤ 2·10<sup class="upper-index">5</sup>; 0 ≤ *k* ≤ 2·10<sup class="upper-index">5</sup>; 0 ≤ *d* ≤ 10<sup class="upper-index">9</sup>). The second line contains *n* space-separated integers: *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub> ( - 10<sup class="upper-index">9</sup> ≤ *a*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>) — the actual sequence.
n, k, d = map(int, input().split())
sequence = list(map(int, input().split()))

best_length = 0
best_start = 0

current_start = 0
current_length = 0
current_max = 0
current_min = float('inf')
count_dict = {}

for i in range(n):
    current_max = max(current_max, sequence[i])
    current_min = min(current_min, sequence[i])
    count_dict[sequence[i]] = count_dict.get(sequence[i], 0) + 1

    while current_max - current_min > d:
        count_dict[sequence[current_start]] -= 1
        if count_dict[sequence[current_start]] == 0:
            current_min = min(filter(lambda x: x > current_min, count_dict.keys()))
        current_start += 1

    if i - current_start + 1 > current_length:
        current_length = i - current_start + 1
        best_start = current_start

print(best_start + 1, best_start + current_length)
