```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

var (
	n     int
	k     int64
	a     []int
	rank  []int
	P     []int64
	S     []int64
	maxn  int
	tree1 []int64
	tree2 []int64
	tstamp1 []int
	tstamp2 []int
	curr_time int
)

func main() {
	in := bufio.NewScanner(os.Stdin)
	in.Split(bufio.ScanWords)
	fmt.Scan(&n, &k)
	a = make([]int, n+1)
	rank = make([]int, n+1)
	P = make([]int64, n+1)
	S = make([]int64, n+2)
	var all []int = make([]int, n)
	for i := 1; i <= n; i++ {
		fmt.Scan(&a[i])
		all[i-1] = a[i]
	}
	sort.Ints(all)
	var unique []int
	for i := 0; i < n; i++ {
		if i == 0 || all[i] != all[i-1] {
			unique = append(unique, all[i])
		}
	}
	maxn = len(unique)
	for i := 1; i <= n; i++ {
		rank[i] = sort.SearchInts(unique, a[i]) + 1
	}
	computeP()
	computeS()
	tree1 = make([]int64, maxn+10)
	tree2 = make([]int64, maxn+10)
	tstamp1 = make([]int, maxn+10)
	tstamp2 = make([]int, maxn+10)
	fmt.Println(solve(1, n))
}

func computeP() {
	tmp_tree := make([]int64, maxn+10)
	tmp_update := func(pos int, val int64) {
		for pos <= maxn {
			tmp_tree[pos] += val
			pos += pos & -pos
		}
	}
	tmp_query := func(pos int) int64 {
		var res int64
		for pos > 0 {
			res += tmp_tree[pos]
			pos -= pos & -pos
		}
		return res
	}
	P[0] = 0
	for i := 1; i <= n; i++ {
		added := tmp_query(maxn) - tmp_query(rank[i])
		P[i] = P[i-1] + added
		tmp_update(rank[i], 1)
	}
}

func computeS() {
	tmp_tree := make([]int64, maxn+10)
	tmp_update := func(pos int, val int64) {
		for pos <= maxn {
			tmp_tree[pos] += val
			pos += pos & -pos
		}
	}
	tmp_query := func(pos int) int64 {
		var res int64
		for pos > 0 {
			res += tmp_tree[pos]
			pos -= pos & -pos
		}
		return res
	}
	S[n+1] = 0
	for i := n; i >= 1; i-- {
		added := tmp_query(rank[i]-1)
		S[i] = S[i+1] + added
		tmp_update(rank[i], 1)
	}
}

func update1(pos int, val int64) {
	for p := pos; p <= maxn; p += p & -p {
		if tstamp1[p] != curr_time {
			tree1[p] = 0
			tstamp1[p] = curr_time
		}
		tree1[p] += val
	}
}

func query1(pos int) int64 {
	var sum int64
	for p := pos; p > 0; p -= p & -p {
		if tstamp1[p] != curr_time {
			tree1[p] = 0
			tstamp1[p] = curr_time
		}
		sum += tree1[p]
	}
	return sum
}

func update2(pos int, val int64) {
	for p := pos; p <= maxn; p += p & -p {
		if tstamp2[p] != curr_time {
			tree2[p] = 0
			tstamp2[p] = curr_time
		}
		tree2[p] += val
	}
}

func query2(pos int) int64 {
	var sum int64
	for p := pos; p > 0; p -= p & -p {
		if tstamp2[p] != curr_time {
			tree2[p] = 0
			tstamp2[p] = curr_time
		}
		sum += tree2[p]
	}
	return sum
}

func solve(L, R int) int64 {
	if L >= R {
		return 0
	}
	mid := (L + R) / 2
	ans := solve(L, mid) + solve(mid+1, R)
	curr_time++
	var current_cross int64
	pointer := mid
	for i := L; i <= mid; i++ {
		update1(rank[i], 1)
	}
	for rr := R; rr >= mid+1; rr-- {
		update2(rank[rr], 1)
		addd := query1(maxn) - query1(rank[rr])
		current_cross += addd
		for pointer >= L && P[pointer]+S[rr]+current_cross > k {
			subb := query2(rank[pointer]-1)
			current_cross -= subb
			update1(rank[pointer], -1)
			pointer--
		}
		ans += int64(pointer - L + 1)
	}
	return ans
}
```