package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"os"
)

const MAXV = 100005

var tree [200015]int32
var dp [500005][8]uint64
var P1 [500005]int32
var P2 [500005]int32
var a [500005]int

func update(idx int, val int32) {
	for idx += MAXV; idx > 0; idx >>= 1 {
		tree[idx] = val
	}
}

func query(l, r int) int32 {
	var res int32 = 0
	for l, r = l+MAXV, r+MAXV+1; l < r; l, r = l>>1, r>>1 {
		if l&1 != 0 {
			if tree[l] > res {
				res = tree[l]
			}
			l++
		}
		if r&1 != 0 {
			r--
			if tree[r] > res {
				res = tree[r]
			}
		}
	}
	return res
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	t := readInt(reader)
	for tc := 0; tc < t; tc++ {
		n := readInt(reader)
		k := readInt(reader)
		for i := 1; i <= n; i++ {
			a[i] = readInt(reader)
		}

		for r := 1; r <= n; r++ {
			ar := a[r]
			minV := ar - k
			if minV < 1 {
				minV = 1
			}
			maxV := ar + k
			if maxV > 100000 {
				maxV = 100000
			}

			j1 := query(minV, maxV)
			var j2 int32 = 0
			if j1 > 0 {
				aj1 := a[j1]
				L_min := minV
				L_max := aj1 - k - 1
				if L_min <= L_max {
					v := query(L_min, L_max)
					if v > j2 {
						j2 = v
					}
				}
				R_min := aj1 + k + 1
				R_max := maxV
				if R_min <= R_max {
					v := query(R_min, R_max)
					if v > j2 {
						j2 = v
					}
				}
			}
			P1[r] = j1
			P2[r] = j2
			update(ar, int32(r))
		}

		var ans int64 = 0
		for startL := 1; startL <= n; startL += 512 {
			endL := startL + 511
			if endL > n {
				endL = n
			}

			for r := 1; r <= n; r++ {
				var v0, v1, v2, v3, v4, v5, v6, v7 uint64
				if j1 := P1[r]; j1 > 0 {
					v0, v1, v2, v3 = dp[j1][0], dp[j1][1], dp[j1][2], dp[j1][3]
					v4, v5, v6, v7 = dp[j1][4], dp[j1][5], dp[j1][6], dp[j1][7]
				}
				if j2 := P2[r]; j2 > 0 {
					v0 |= dp[j2][0]
					v1 |= dp[j2][1]
					v2 |= dp[j2][2]
					v3 |= dp[j2][3]
					v4 |= dp[j2][4]
					v5 |= dp[j2][5]
					v6 |= dp[j2][6]
					v7 |= dp[j2][7]
				}
				if r >= startL && r <= endL {
					bit := uint32(r - startL)
					shift := bit & 63
					switch bit >> 6 {
					case 0:
						v0 |= uint64(1) << shift
					case 1:
						v1 |= uint64(1) << shift
					case 2:
						v2 |= uint64(1) << shift
					case 3:
						v3 |= uint64(1) << shift
					case 4:
						v4 |= uint64(1) << shift
					case 5:
						v5 |= uint64(1) << shift
					case 6:
						v6 |= uint64(1) << shift
					case 7:
						v7 |= uint64(1) << shift
					}
				}
				dp[r][0], dp[r][1], dp[r][2], dp[r][3] = v0, v1, v2, v3
				dp[r][4], dp[r][5], dp[r][6], dp[r][7] = v4, v5, v6, v7

				ans += int64(bits.OnesCount64(v0) + bits.OnesCount64(v1) + bits.OnesCount64(v2) + bits.OnesCount64(v3) +
					bits.OnesCount64(v4) + bits.OnesCount64(v5) + bits.OnesCount64(v6) + bits.OnesCount64(v7))
			}
		}
		fmt.Fprintln(writer, ans)

		for r := 1; r <= n; r++ {
			update(a[r], 0)
		}
	}
}

func readInt(r *bufio.Reader) int {
	var res int
	var sign int = 1
	var c byte
	for {
		c, _ = r.ReadByte()
		if c == '-' {
			sign = -1
			break
		}
		if c >= '0' && c <= '9' {
			res = int(c - '0')
			break
		}
	}
	for {
		c, err := r.ReadByte()
		if err != nil || c < '0' || c > '9' {
			break
		}
		res = res*10 + int(c-'0')
	}
	return res * sign
}