In the lattice points of the coordinate line there are *n* radio stations, the *i*-th of which is described by three integers:
 -  *x*<sub class="lower-index">*i*</sub> — the coordinate of the *i*-th station on the line, -  *r*<sub class="lower-index">*i*</sub> — the broadcasting range of the *i*-th station, -  *f*<sub class="lower-index">*i*</sub> — the broadcasting frequency of the *i*-th station. 
We will say that two radio stations with numbers *i* and *j* reach each other, if the broadcasting range of each of them is more or equal to the distance between them. In other words *min*(*r*<sub class="lower-index">*i*</sub>, *r*<sub class="lower-index">*j*</sub>) ≥ |*x*<sub class="lower-index">*i*</sub> - *x*<sub class="lower-index">*j*</sub>|.

Let's call a pair of radio stations (*i*, *j*) bad if *i* &lt; *j*, stations *i* and *j* reach each other and they are close in frequency, that is, |*f*<sub class="lower-index">*i*</sub> - *f*<sub class="lower-index">*j*</sub>| ≤ *k*.

Find the number of bad pairs of radio stations.
The first line contains two integers *n* and *k* (1 ≤ *n* ≤ 10<sup class="upper-index">5</sup>, 0 ≤ *k* ≤ 10) — the number of radio stations and the maximum difference in the frequencies for the pair of stations that reach each other to be considered bad.

In the next *n* lines follow the descriptions of radio stations. Each line contains three integers *x*<sub class="lower-index">*i*</sub>, *r*<sub class="lower-index">*i*</sub> and *f*<sub class="lower-index">*i*</sub> (1 ≤ *x*<sub class="lower-index">*i*</sub>, *r*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>, 1 ≤ *f*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">4</sup>) — the coordinate of the *i*-th radio station, it's broadcasting range and it's broadcasting frequency. No two radio stations will share a coordinate.
none
3 2
1 3 10
3 2 5
4 10 8
1
3 3
1 3 10
3 2 5
4 10 8
2
5 1
1 3 2
2 2 4
3 2 1
4 2 1
5 3 3
2
5 1
1 5 2
2 5 4
3 5 1
4 5 1
5 5 3
5
1 4
6 8 16
0
import bisect
import sys
input = sys.stdin.readline

def make_tree(n):
    tree = [0] * (n + 1)
    return tree

def get_sum(i):
    s = 0
    while i > 0:
        s += tree[i]
        i -= i & -i
    return s

def add(i, x):
    while i <= n:
        tree[i] += x
        i += i & -i

n, k = map(int, input().split())
l = pow(10, 4)
inf = pow(10, 9) + 7
a = [[] for _ in range(l + 25)]
b = [[] for _ in range(l + 25)]
for _ in range(n):
    x, r, f = map(int, input().split())
    a[f + 10].append((x, r))
    b[f + 10].append((r, x))
y = [[] for _ in range(l + 25)]
n = 0
for i in range(11, l + 11):
    a[i].sort()
    b[i].sort()
    n = max(n, len(a[i]))
    for x, r in a[i]:
        y[i].append(x)
tree = make_tree(n)
ans = 0
for i in range(11, l + 11):
    if not y[i]:
        continue
    yi = y[i]
    d = dict()
    for j in range(len(yi)):
        d[yi[j]] = j + 1
    bi = b[i]
    for j in range(len(yi)):
        r, x = bi[j]
        s = bisect.bisect_left(yi, x + r + 0.5)
        t = bisect.bisect_left(yi, x - r - 0.5)
        ans += s - t - 1
        ans -= get_sum(s) - get_sum(t)
        add(d[x], 1)
    for j in range(1, len(yi) + 1):
        add(j, -1)
    for j in range(i + 1, i + k + 1):
        if not y[j]:
            continue
        bj = b[j]
        u, v = 0, 0
        ri, xi = bi[0]
        rj, xj = bj[0]
        while not len(bi) + len(bj) == u + v:
            if ri < rj:
                add(d[xi], 1)
                u += 1
                if u == len(bi):
                    ri, xi = inf, inf
                else:
                    ri, xi = bi[u]
            else:
                s = bisect.bisect_left(yi, xj + rj + 0.5)
                t = bisect.bisect_left(yi, xj - rj - 0.5)
                ans += s - t
                ans -= get_sum(s) - get_sum(t)
                v += 1
                if v == len(bj):
                    rj, xj = inf, inf
                else:
                    rj, xj = bj[v]
        for i0 in range(1, len(yi) + 1):
            add(i0, -1)
    for j in range(i - k, i):
        if not y[j]:
            continue
        bj = b[j]
        u, v = 0, 0
        ri, xi = bi[0]
        rj, xj = bj[0]
        while not len(bi) + len(bj) == u + v:
            if ri <= rj:
                add(d[xi], 1)
                u += 1
                if u == len(bi):
                    ri, xi = inf, inf
                else:
                    ri, xi = bi[u]
            else:
                s = bisect.bisect_left(yi, xj + rj + 0.5)
                t = bisect.bisect_left(yi, xj - rj - 0.5)
                ans += s - t
                ans -= get_sum(s) - get_sum(t)
                v += 1
                if v == len(bj):
                    rj, xj = inf, inf
                else:
                    rj, xj = bj[v]
        for i0 in range(1, len(yi) + 1):
            add(i0, -1)
print(ans)