---

import sys

# Настройка для быстрого ввода-вывода
input = sys.stdin.read

def solve():
    lines = input().split()
    if not lines:
        return
    
    n = int(lines[0])
    t = int(lines[1])
    k = [int(x) for x in lines[2:2+n]]
    
    # Сжатие координат цен, чтобы использовать дерево Фенвика
    # Нам понадобятся сами цены k[i], а также границы k[i]-t, k[i]+t, k[i]+t
    all_vals = set()
    for x in k:
        all_vals.add(x)
        all_vals.add(x - t)
        all_vals.add(x + t)
        
    sorted_vals = sorted(list(all_vals))
    val_to_idx = {val: i + 1 for i, val in enumerate(sorted_vals)}
    MAX_IDX = len(sorted_vals)
    
    # Дерево Фенвика (Fenwick Tree / Binary Indexed Tree)
    bit = [0] * (MAX_IDX + 1)
    
    def update(idx, delta):
        while idx <= MAX_IDX:
            bit[idx] += delta
            idx += idx & (-idx)
            
    def query(idx):
        s = 0
        while idx > 0:
            s += bit[idx]
            idx -= idx & (-idx)
        return s

    def query_range(left_val, right_val):
        l_idx = val_to_idx[left_val]
        r_idx = val_to_idx[right_val]
        return query(r_idx) - query(l_idx - 1)

    # Шаг 1: Сначала посчитаем для каждого товара `i`, сколько справа (индексы m > i) 
    # есть товаров таких, что |k[m] - k[i]| > t.
    # Это эквивалентно: k[m] < k[i] - t ИЛИ k[m] > k[i] + t
    
    # Заполняем Дерево Фенвика всеми элементами справа (изначально — весь массив)
    for x in k:
        update(val_to_idx[x], 1)
        
    valid_m_count = [0] * n
    for i in range(n):
        x = k[i]
        # Убираем текущий элемент из «правой части»
        update(val_to_idx[x], -1)
        
        # Считаем элементы k[m] < x - t
        low_zone = query(val_to_idx[x - t] - 1)
        # Считаем элементы k[m] > x + t
        high_zone = query(MAX_IDX) - query(val_to_idx[x + t])
        
        valid_m_count[i] = low_zone + high_zone

    # Шаг 2: Теперь используем еще одно дерево Фенвика (или то же самое, очистив его),
    # чтобы идти слева направо и для каждого второго товара `j` понимать,
    # сколько товаров `i` слева подходят по условию |k[j] - k[i]| <= t.
    # Но так как все условия завязаны на первый товар `i`, эффективнее сделать наоборот:
    # перебирать `i` от 0 до n-1, и нам нужно знать, сколько `j` (где j > i) удовлетворяют |k[j] - k[i]| <= t,
    # и для каждого такого `j` умножить на сохраненное количество способов выбрать `m` для этого `j`.
    
    # Очищаем дерево для нового прохода
    bit = [0] * (MAX_IDX + 1)
    
    # Идем с конца массива к началу, чтобы эффективно обрабатывать пары (i, j)
    ans = 0
    for idx in range(n - 1, -1, -1):
        x = k[idx]
        
        # Текущий элемент выступает в роли первого товара в чеке (индекс i).
        # Нам нужно узнать сумму valid_m_count[j] для всех j > i, у которых |k[j] - x| <= t.
        # То есть x - t <= k[j] <= x + t.
        ans += query_range(x - t, x + t)
        
        # Теперь добавляем текущий элемент в дерево как потенциальный ВТОРОЙ товар (индекс j)
        # В дерево мы добавляем не единицу, а количество способов выбрать для него третий товар m
        update(val_to_idx[x], valid_m_count[idx])

    print(ans)

if __name__ == '__main__':
    solve()