// XXX: http://codeforces.com/problemset/problem/220/E
#if 1
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <assert.h>
#include <stddef.h>
#include <unistd.h>
#include <sys/time.h>
#include <math.h>
#include <stdint.h>
#include <ctype.h>

#ifdef CACA_COMUN_LOG
#include <execinfo.h>
#endif

#ifdef __MACH__
#include <mach/clock.h>
#include <mach/mach.h>
#else
#include <time.h>
#include <stdarg.h>
#endif

#if 1
#ifndef LONG_LONG_MAX
#define LONG_LONG_MAX LONG_MAX
#endif

#define CACA_COMUN_TAM_MAX_LINEA (16*200000)
#define CACA_LOG_MAX_TAM_CADENA 2000

#define CACA_COMUN_BUF_STATICO (char[1000] ) { '\0' }

#define BITCH_VECTOR_NUM_BITS (sizeof(bitch_vector) * 8)

#define CACA_COMUN_ASSERT_DUROTE 0
#define CACA_COMUN_ASSERT_SUAVECITO 1
#define CACA_COMUN_ASSERT_NIMADRES 2

#define CACA_COMUN_VALOR_INVALIDO ((tipo_dato)UINT_MAX)
#define CACA_COMUN_IDX_INVALIDO ((natural)CACA_COMUN_VALOR_INVALIDO)
//#define CACA_COMUN_LOG

typedef unsigned int natural;
typedef int tipo_dato;
typedef long long entero_largo;
typedef unsigned long long entero_largo_sin_signo;
typedef long long bitch_vector;
typedef char byteme;

typedef enum BOOLEANOS {
	falso = 0, verdadero
} bool;

/*
 #define CACA_COMUN_TIPO_ASSERT CACA_COMUN_ASSERT_SUAVECITO
 #define CACA_COMUN_TIPO_ASSERT CACA_COMUN_ASSERT_NIMADRES
 */
#define CACA_COMUN_TIPO_ASSERT CACA_COMUN_ASSERT_DUROTE

#define assert_timeout_dummy(condition) 0;

#if CACA_COMUN_TIPO_ASSERT == CACA_COMUN_ASSERT_DUROTE
#define assert_timeout(condition) assert(condition);
#endif
#if CACA_COMUN_TIPO_ASSERT == CACA_COMUN_ASSERT_SUAVECITO
#define assert_timeout(condition) if(!(condition)){while(1){printf("");};abort();}
#endif
#if CACA_COMUN_TIPO_ASSERT == CACA_COMUN_ASSERT_NIMADRES
#define assert_timeout(condition) 0
#endif

#ifdef CACA_COMUN_LOG
#define caca_log_debug(formato, args...) \
		do \
		{ \
			size_t profundidad = 0; \
			void *array[CACA_LOG_MAX_TAM_CADENA]; \
 			profundidad = backtrace(array, CACA_LOG_MAX_TAM_CADENA); \
			caca_log_debug_func(formato,__FILE__, __func__, __LINE__,profundidad,##args); \
		} \
		while(0);
#else
#define caca_log_debug(formato, args...) 0;
#endif

#define caca_comun_max(x,y) ((x) < (y) ? (y) : (x))
#define caca_comun_min(x,y) ((x) < (y) ? (x) : (y))

#define caca_comun_calloc_local(tipo) (&(tipo){0})

void caca_log_debug_func(const char *format, ...);

void caca_comun_current_utc_time(struct timespec *ts) {

#ifdef __MACH__
	clock_serv_t cclock;
	mach_timespec_t mts;
	host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
	clock_get_time(cclock, &mts);
	mach_port_deallocate(mach_task_self(), cclock);
	ts->tv_sec = mts.tv_sec;
	ts->tv_nsec = mts.tv_nsec;
#else
#ifdef CACA_COMUN_LOG
	clock_gettime(CLOCK_REALTIME, ts);
#endif
#endif

}

void caca_comun_timestamp(char *stime) {
	time_t ltime;
	struct tm result;
	long ms;
#ifndef ONLINE_JUDGE
	struct timespec spec;
#endif
	char parte_milisecundos[50];

	ltime = time(NULL);

#ifndef ONLINE_JUDGE
	localtime_r(&ltime, &result);
	asctime_r(&result, stime);
#endif

	*(stime + strlen(stime) - 1) = ' ';

#ifndef ONLINE_JUDGE
	caca_comun_current_utc_time(&spec);
	ms = round(spec.tv_nsec / 1.0e3);
#endif
	sprintf(parte_milisecundos, "%ld", ms);
	strcat(stime, parte_milisecundos);
}
#ifdef CACA_COMUN_LOG
void caca_log_debug_func(const char *format, ...) {

	va_list arg;
	va_list arg2;
	const char *PEDAZO_TIMESTAMP_HEADER = "tiempo: %s; ";
	const char *HEADER =
	"archivo: %s; funcion: %s; linea %d; nivel: %zd caca 8====D ";
	char formato[CACA_LOG_MAX_TAM_CADENA + sizeof(HEADER)
	+ sizeof(PEDAZO_TIMESTAMP_HEADER)] = {'\0'};
	char pedazo_timestamp[sizeof(PEDAZO_TIMESTAMP_HEADER) + 100] = {'\0'};
	char cadena_timestamp[100] = {'\0'};

	caca_comun_timestamp(cadena_timestamp);
	sprintf(pedazo_timestamp, PEDAZO_TIMESTAMP_HEADER, cadena_timestamp);

	strcpy(formato, pedazo_timestamp);
	strcat(formato, HEADER);
	strcat(formato, format);
	strcat(formato, "\n");

	va_start(arg, format);
	va_copy(arg2, arg);
	vprintf(formato, arg2);
	va_end(arg2);
	va_end(arg);
	setbuf(stdout, NULL);
}
#endif

#ifdef CACA_COMUN_LOG
static char *caca_comun_arreglo_a_cadena(tipo_dato *arreglo, int tam_arreglo,
		char *buffer) {
	int i;
	char *ap_buffer = NULL;
	int characteres_escritos = 0;
#ifdef ONLINE_JUDGE
	return NULL;
#endif

	memset(buffer, 0, 100);
	ap_buffer = buffer;

	for (i = 0; i < tam_arreglo; i++) {
		characteres_escritos += sprintf(ap_buffer + characteres_escritos,
				"%12d", *(arreglo + i));
		if (i < tam_arreglo - 1) {
			*(ap_buffer + characteres_escritos++) = ',';
		}
	}
	*(ap_buffer + characteres_escritos) = '\0';
	return ap_buffer;
}

static char *caca_comun_arreglo_a_cadena_natural(natural *arreglo,
		natural tam_arreglo, char *buffer) {
	int i;
	char *ap_buffer = NULL;
	int characteres_escritos = 0;
#ifdef ONLINE_JUDGE
	return NULL;
#endif

	memset(buffer, 0, 100);
	ap_buffer = buffer;

	for (i = 0; i < tam_arreglo; i++) {
		characteres_escritos += sprintf(ap_buffer + characteres_escritos, "%2u",
				*(arreglo + i));
		if (i < tam_arreglo - 1) {
			*(ap_buffer + characteres_escritos++) = ',';
		}
	}
	*(ap_buffer + characteres_escritos) = '\0';
	return ap_buffer;
}
char *caca_comun_matrix_a_cadena(tipo_dato *matrix, natural filas_tam,
		natural columas_tam, char *buffer) {
	int i, j;
	natural inicio_buffer_act = 0;
	for (int i = 0; i < filas_tam; i++) {
		caca_comun_arreglo_a_cadena(matrix + i * columas_tam, columas_tam,
				buffer + inicio_buffer_act);
		inicio_buffer_act += strlen(buffer + inicio_buffer_act);
		buffer[inicio_buffer_act++] = '\n';
		/*		caca_log_debug("pero q mierda inicio buffer act %u %s",inicio_buffer_act,buffer);*/
	}
	return buffer;
}

static char *caca_comun_arreglo_a_cadena_entero_largo_sin_signo(
		entero_largo_sin_signo *arreglo, entero_largo_sin_signo tam_arreglo,
		char *buffer) {
	int i;
	char *ap_buffer = NULL;
	int characteres_escritos = 0;
#ifdef ONLINE_JUDGE
	return NULL;
#endif

	memset(buffer, 0, 100);
	ap_buffer = buffer;

	for (i = 0; i < tam_arreglo; i++) {
		characteres_escritos += sprintf(ap_buffer + characteres_escritos,
				"%llu", *(arreglo + i));
		if (i < tam_arreglo - 1) {
			*(ap_buffer + characteres_escritos++) = ',';
		}
	}
	*(ap_buffer + characteres_escritos) = '\0';
	return ap_buffer;
}
#else
static char *caca_comun_arreglo_a_cadena(tipo_dato *arreglo, int tam_arreglo,
		char *buffer) {
	return NULL;
}
static char *caca_comun_arreglo_a_cadena_natural(natural *arreglo,
		natural tam_arreglo, char *buffer) {
	return NULL;
}
char *caca_comun_matrix_a_cadena(tipo_dato *matrix, natural filas_tam,
		natural columas_tam, char *buffer) {
	return NULL;
}

static char *caca_comun_arreglo_a_cadena_entero_largo_sin_signo(
		entero_largo_sin_signo *arreglo, entero_largo_sin_signo tam_arreglo,
		char *buffer) {
	return NULL;
}
#endif
void caca_comun_strreplace(char s[], char chr, char repl_chr) {
	int i = 0;
	while (s[i] != '\0') {
		if (s[i] == chr) {
			s[i] = repl_chr;
		}
		i++;
	}
}

static int caca_comun_lee_matrix_long_stdin(tipo_dato *matrix, int *num_filas,
		int *num_columnas, int num_max_filas, int num_max_columnas) {
	int indice_filas = 0;
	int indice_columnas = 0;
	tipo_dato numero = 0;
	char *siguiente_cadena_numero = NULL;
	char *cadena_numero_actual = NULL;
	char *linea = NULL;

	linea = calloc(CACA_COMUN_TAM_MAX_LINEA, sizeof(char));

	while (indice_filas < num_max_filas
			&& fgets(linea, CACA_COMUN_TAM_MAX_LINEA, stdin)) {
		indice_columnas = 0;
		cadena_numero_actual = linea;
		caca_comun_strreplace(linea, '\n', '\0');
		if (!strlen(linea)) {
			caca_log_debug("weird, linea vacia");
			continue;
		}
		for (siguiente_cadena_numero = linea;; siguiente_cadena_numero =
				cadena_numero_actual) {
			numero = strtol(siguiente_cadena_numero, &cadena_numero_actual, 10);
			if (cadena_numero_actual == siguiente_cadena_numero) {
				break;
			}
			*(matrix + indice_filas * num_max_columnas + indice_columnas) =
					numero;
			indice_columnas++;
		}
		if (num_columnas) {
			num_columnas[indice_filas] = indice_columnas;
		}
		indice_filas++;
		caca_log_debug("las filas son %d, con clos %d", indice_filas,
				indice_columnas);
	}

	*num_filas = indice_filas;
	free(linea);
	return 0;
}

static inline natural caca_comun_cuenta_bitchs(tipo_dato num) {
	natural bitch_cnt = 0;
	tipo_dato num_mod = 0;
	num_mod = num;
	while (num_mod) {
		num_mod &= ~(num_mod & (-num_mod));
		bitch_cnt++;
	}
	return bitch_cnt;
}

static inline char caca_comun_letra_a_valor_minuscula(char letra) {
	return letra - 'a';
}

static inline natural caca_comun_max_natural(natural *nums, natural nums_tam) {
	natural max = 0;

	for (int i = 0; i < nums_tam; i++) {
		natural num_act = nums[i];
		if (num_act > max) {
			max = num_act;
		}
	}

	return max;
}

// XXX: https://stackoverflow.com/questions/122616/how-do-i-trim-leading-trailing-whitespace-in-a-standard-way?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa
static inline char *caca_comun_trimea(char *cad, natural cad_tam) {
	char c = cad[0];
	char tmp = '\0';
	natural i = 0;
	natural j = 0;

	caca_log_debug("entrada %s cad_tam %u", cad, cad_tam);
	while (j < cad_tam && cad[j] != '\0') {
		caca_log_debug("en j %u car %c", j, cad[j]);
		while (j < cad_tam && !isalpha(cad[j])) {
			caca_log_debug("brincando j %u car %c", j, cad[j]);
			j++;
		}
		caca_log_debug("aora j %u car %c", j, cad[j]);
		if (j == cad_tam) {
			caca_log_debug("q ped");
			break;
		}
		tmp = cad[i];
		cad[i] = cad[j];
		cad[j] = tmp;
		i++;
		j++;
	}
	caca_log_debug("mierda '%c'", cad[j]);

	i = 0;
	while (isalpha(cad[i++]))
		;
	caca_log_debug("salida %s", cad);
	cad[i - 1] = '\0';

	return cad;
}

#endif

#endif

#if 1
typedef struct numero_orden {
	int numero;
	natural posicion_inicial;
} numero_orden;

static int compara_numero_orden(const void *pa, const void *pb) {
	numero_orden *a = (numero_orden *) pa;
	numero_orden *b = (numero_orden *) pb;
	int r = 0;

	r = a->numero - b->numero;

	if (!r) {
		r = a->posicion_inicial - b->posicion_inicial;
	}

	assert(r);

	return r;
}

static inline natural *mapear_a_posicion_ordenada(natural *nums,
		natural nums_tam, natural *nums_res, natural nums_res_tam) {
	numero_orden *nums_ord = NULL;

	assert(nums_res_tam >= nums_tam);

	nums_ord = calloc(nums_tam, sizeof(numero_orden));
	assert(nums_ord);

	for (natural i = 0; i < nums_tam; i++) {
		numero_orden *num_ord_act = nums_ord + i;

		num_ord_act->numero = nums[i];
		num_ord_act->posicion_inicial = i;
	}

	qsort(nums_ord, nums_tam, sizeof(numero_orden), compara_numero_orden);

	for (natural i = 0; i < nums_tam; i++) {
		numero_orden *num_ord_act = nums_ord + i;
		nums_res[num_ord_act->posicion_inicial] = i;
	}

	free(nums_ord);
	return nums_res;
}
#endif

#if 1

#define BIT_CH_VALOR_INVALIDO ULLONG_MAX

typedef struct bit_ch {
	natural num_nodos_bit_ch;
	tipo_dato *nodos_bit_ch;
} bit_ch;

static inline void bit_ch_aumenta(bit_ch *bit, tipo_dato nuevo_valor,
		natural idx);

static inline void bit_ch_init(bit_ch *bit, tipo_dato valor_inicial,
		natural num_cacas) {
	tipo_dato *nodos = NULL;

	bit->num_nodos_bit_ch = num_cacas + 2;

	bit->nodos_bit_ch = calloc(bit->num_nodos_bit_ch, sizeof(tipo_dato));
	nodos = bit->nodos_bit_ch;

	nodos[0] = (tipo_dato) BIT_CH_VALOR_INVALIDO;
	for (natural i = 1; i < bit->num_nodos_bit_ch; i++) {
		nodos[i] = 0;
	}

	bit_ch_aumenta(bit, valor_inicial, 1);
}

static inline void bit_ch_fini(bit_ch *bit) {
	free(bit->nodos_bit_ch);
}

static inline void bit_ch_aumenta(bit_ch *bit, tipo_dato nuevo_valor,
		natural idx) {
	tipo_dato *nodos = bit->nodos_bit_ch;
	caca_log_debug("q verga actualizando %u con %d", idx, nuevo_valor);
	for (natural i = idx; i && i < bit->num_nodos_bit_ch; i += (i & (-i))) {
		caca_log_debug("actualizando caca %u con %d antes %d", i, nuevo_valor,
				nodos[i]);
		nodos[i] += nuevo_valor;
		caca_log_debug("actualizado caca %u aora %d", i, nodos[i]);
	}
}

static inline tipo_dato bit_ch_consulta(bit_ch *bit, natural idx) {
	tipo_dato *nodos = bit->nodos_bit_ch;
	tipo_dato res = 0;
	for (int i = idx; i > 0; i -= (i & (-i))) {
		assert_timeout(i < bit->num_nodos_bit_ch);
		caca_log_debug("consultando caca %u tiene %u", i, nodos[i]);
		res += nodos[i];
	}
	caca_log_debug("regresando %d", res);
	return res;
}

static inline tipo_dato bit_ch_consulta_rango_actualizacion_puntual(bit_ch *bit,
		natural i, natural j) {
	return bit_ch_consulta(bit, j) - bit_ch_consulta(bit, i - 1);
}

static inline tipo_dato bit_ch_consulta_fondo(bit_ch *bit, natural i) {
	return bit_ch_consulta_rango_actualizacion_puntual(bit, i,
			bit->num_nodos_bit_ch - 1);
}

static inline void bit_ch_aumenta_rango(bit_ch *bit, tipo_dato nuevo_valor,
		natural idx_ini, natural idx_fin) {
	caca_log_debug("aumentando de %u a %u con valor %llu", idx_ini, idx_fin,
			nuevo_valor);

	bit_ch_aumenta(bit, nuevo_valor, idx_ini);
	bit_ch_aumenta(bit, -nuevo_valor, idx_fin + 1);
}

static inline void bit_ch_aumenta_rango_consulta_rango(bit_ch *bit_puto,
		bit_ch *bit_aux, natural idx_ini, natural idx_fin,
		tipo_dato nuevo_valor) {

	caca_log_debug("aumentando de %u a %u con valor %llu para consulta rango",
			idx_ini, idx_fin, nuevo_valor);

	bit_ch_aumenta_rango(bit_puto, nuevo_valor, idx_ini, idx_fin);
	caca_log_debug(
			"actualizando para consulta rango inicial %d con %llu (%llu * %u)",
			idx_ini, nuevo_valor * (idx_ini - 1), nuevo_valor, idx_ini - 1);
	bit_ch_aumenta(bit_aux, nuevo_valor * (idx_ini - 1), idx_ini);
	caca_log_debug(
			"actualizando para consulta rango final %d con %llu(%llu,%u)",
			idx_fin + 1, -nuevo_valor * idx_fin, -nuevo_valor, idx_fin);
	bit_ch_aumenta(bit_aux, -nuevo_valor * idx_fin, idx_fin + 1);
}

static inline tipo_dato bit_ch_consulta_rango_actualizado_rango(
		bit_ch *bit_puto, bit_ch *bit_aux, natural idx) {
	tipo_dato resul = 0;
	tipo_dato valor_puto = 0;
	tipo_dato valor_aux = 0;

	valor_puto = bit_ch_consulta(bit_puto, idx);

	caca_log_debug("el valor putual en %u es %llu, aportara %llu (%llu * %u)",
			idx, valor_puto, valor_puto * idx, valor_puto, idx);

	valor_aux = bit_ch_consulta(bit_aux, idx);

	caca_log_debug("el valor aux en %u es %llu", idx, valor_puto);

	resul = valor_puto * idx - valor_aux;

	caca_log_debug("la suma acumulacaca hasta %u es %llu", idx, resul);

	return resul;
}

static inline tipo_dato bit_ch_consulta_rango(bit_ch *bit_puto, bit_ch *bit_aux,
		natural idx_ini, natural idx_fin) {
	tipo_dato resul = 0;
	tipo_dato resul_idx_ini = 0;
	tipo_dato resul_idx_fin = 0;

	resul_idx_ini = bit_ch_consulta_rango_actualizado_rango(bit_puto, bit_aux,
			idx_ini - 1);
	caca_log_debug("la suma acumulacaca ini hasta %u es %llu", idx_ini,
			resul_idx_ini);

	resul_idx_fin = bit_ch_consulta_rango_actualizado_rango(bit_puto, bit_aux,
			idx_fin);
	caca_log_debug("la suma acumulacaca fin hasta %u es %llu", idx_fin,
			resul_idx_fin);

	resul = resul_idx_fin - resul_idx_ini;

	caca_log_debug("la suma acumulacaca del rango %u-%u es %llu", idx_ini,
			idx_fin, resul);

	return resul;
}

#endif

static inline natural modifica(bit_ch *bi, bit_ch *bd, natural *a, natural i,
		bool quitar) {
	natural inv = 0;
	bit_ch *bm = NULL;
	int factor = 0;
	inv = bit_ch_consulta_fondo(bi, a[i] + 1) + bit_ch_consulta(bd, a[i] - 1);

	if (quitar) {
		bm = bd;
		factor = -1;
	} else {
		bm = bi;
		factor = 1;
	}
	caca_log_debug("el puto factor %d", factor);

	bit_ch_aumenta(bm, factor, a[i]);
	caca_log_debug("las inv al %s %u son %u", quitar?"quitar":"poner", a[i],
			inv);

	return inv;
}

static inline natural quita(bit_ch *bi, bit_ch *bd, natural *a, natural i) {
	return modifica(bi, bd, a, i, verdadero);
}

static inline natural anade(bit_ch *bi, bit_ch *bd, natural *a, natural i) {
	return modifica(bi, bd, a, i, falso);
}

static inline entero_largo_sin_signo core(natural *nums, natural nums_tam,
		entero_largo_sin_signo k) {
	entero_largo_sin_signo inv = 0;
	bit_ch *bi = caca_comun_calloc_local(bit_ch);
	bit_ch *bd = caca_comun_calloc_local(bit_ch);
	natural j = 0;
	entero_largo_sin_signo r = 0;
	natural *a = NULL;

	a = calloc(nums_tam, sizeof(natural));
	assert_timeout(a);

	mapear_a_posicion_ordenada(nums, nums_tam, a, nums_tam);
	for (natural i = 0; i < nums_tam; i++) {
		a[i]++;
	}
	caca_log_debug("mapeados %s",
			caca_comun_arreglo_a_cadena_natural(a, nums_tam, CACA_COMUN_BUF_STATICO));

	bit_ch_init(bi, 0, nums_tam);
	bit_ch_init(bd, 0, nums_tam);

	for (natural i = 0; i < nums_tam; i++) {
		inv += bit_ch_consulta_fondo(bd, a[i]);
		bit_ch_aumenta(bd, 1, a[i]);
		caca_log_debug("anadiendo %u en pos %u inv %llu", a[i], i, inv);
	}

	caca_log_debug("inv totales %llu", inv);

	inv += anade(bi, bd, a, 0);
	caca_log_debug("inv ini %llu", inv);
	for (natural i = 1; i < nums_tam; i++) {
		while (j < nums_tam && (j < i || inv > k)) {
			inv -= quita(bi, bd, a, j);
			j++;
			caca_log_debug("kitando %u en pos %u inv %llu", a[j-1], j-1, inv);
		}

		r += nums_tam - j;

		caca_log_debug("en %u %u inv %llu r %llu", i, j, inv, r)

		inv += anade(bi, bd, a, i);
	}

	bit_ch_fini(bi);
	bit_ch_fini(bd);

	return r;
}

#define MAX_CACA ((int)1E5)
natural a[MAX_CACA] = { 0 };

int main() {
	natural n = 0;
	entero_largo_sin_signo k = 0;

	scanf("%u %llu\n", &n, &k);
	assert_timeout(n<=MAX_CACA);
	assert_timeout(k <= ((entero_largo_sin_signo )(1E18)));

	for (natural i = 0; i < n; i++) {
		scanf("%u", &a[i]);
	}

	printf("%llu\n", core(a, n, k));
	return EXIT_SUCCESS;
}


// XXX: http://codeforces.com/problemset/problem/220/E
#if 1
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <assert.h>
#include <stddef.h>
#include <unistd.h>
#include <sys/time.h>
#include <math.h>
#include <stdint.h>
#include <ctype.h>

#ifdef CACA_COMUN_LOG
#include <execinfo.h>
#endif

#ifdef __MACH__
#include <mach/clock.h>
#include <mach/mach.h>
#else
#include <time.h>
#include <stdarg.h>
#endif

#if 1
#ifndef LONG_LONG_MAX
#define LONG_LONG_MAX LONG_MAX
#endif

#define CACA_COMUN_TAM_MAX_LINEA (16*200000)
#define CACA_LOG_MAX_TAM_CADENA 2000

#define CACA_COMUN_BUF_STATICO (char[1000] ) { '\0' }

#define BITCH_VECTOR_NUM_BITS (sizeof(bitch_vector) * 8)

#define CACA_COMUN_ASSERT_DUROTE 0
#define CACA_COMUN_ASSERT_SUAVECITO 1
#define CACA_COMUN_ASSERT_NIMADRES 2

#define CACA_COMUN_VALOR_INVALIDO ((tipo_dato)UINT_MAX)
#define CACA_COMUN_IDX_INVALIDO ((natural)CACA_COMUN_VALOR_INVALIDO)
//#define CACA_COMUN_LOG

typedef unsigned int natural;
typedef int tipo_dato;
typedef long long entero_largo;
typedef unsigned long long entero_largo_sin_signo;
typedef long long bitch_vector;
typedef char byteme;

typedef enum BOOLEANOS {
	falso = 0, verdadero
} bool;

/*
 #define CACA_COMUN_TIPO_ASSERT CACA_COMUN_ASSERT_SUAVECITO
 #define CACA_COMUN_TIPO_ASSERT CACA_COMUN_ASSERT_NIMADRES
 */
#define CACA_COMUN_TIPO_ASSERT CACA_COMUN_ASSERT_DUROTE

#define assert_timeout_dummy(condition) 0;

#if CACA_COMUN_TIPO_ASSERT == CACA_COMUN_ASSERT_DUROTE
#define assert_timeout(condition) assert(condition);
#endif
#if CACA_COMUN_TIPO_ASSERT == CACA_COMUN_ASSERT_SUAVECITO
#define assert_timeout(condition) if(!(condition)){while(1){printf("");};abort();}
#endif
#if CACA_COMUN_TIPO_ASSERT == CACA_COMUN_ASSERT_NIMADRES
#define assert_timeout(condition) 0
#endif

#ifdef CACA_COMUN_LOG
#define caca_log_debug(formato, args...) \
		do \
		{ \
			size_t profundidad = 0; \
			void *array[CACA_LOG_MAX_TAM_CADENA]; \
 			profundidad = backtrace(array, CACA_LOG_MAX_TAM_CADENA); \
			caca_log_debug_func(formato,__FILE__, __func__, __LINE__,profundidad,##args); \
		} \
		while(0);
#else
#define caca_log_debug(formato, args...) 0;
#endif

#define caca_comun_max(x,y) ((x) < (y) ? (y) : (x))
#define caca_comun_min(x,y) ((x) < (y) ? (x) : (y))

#define caca_comun_calloc_local(tipo) (&(tipo){0})

void caca_log_debug_func(const char *format, ...);

void caca_comun_current_utc_time(struct timespec *ts) {

#ifdef __MACH__
	clock_serv_t cclock;
	mach_timespec_t mts;
	host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
	clock_get_time(cclock, &mts);
	mach_port_deallocate(mach_task_self(), cclock);
	ts->tv_sec = mts.tv_sec;
	ts->tv_nsec = mts.tv_nsec;
#else
#ifdef CACA_COMUN_LOG
	clock_gettime(CLOCK_REALTIME, ts);
#endif
#endif

}

void caca_comun_timestamp(char *stime) {
	time_t ltime;
	struct tm result;
	long ms;
#ifndef ONLINE_JUDGE
	struct timespec spec;
#endif
	char parte_milisecundos[50];

	ltime = time(NULL);

#ifndef ONLINE_JUDGE
	localtime_r(&ltime, &result);
	asctime_r(&result, stime);
#endif

	*(stime + strlen(stime) - 1) = ' ';

#ifndef ONLINE_JUDGE
	caca_comun_current_utc_time(&spec);
	ms = round(spec.tv_nsec / 1.0e3);
#endif
	sprintf(parte_milisecundos, "%ld", ms);
	strcat(stime, parte_milisecundos);
}
#ifdef CACA_COMUN_LOG
void caca_log_debug_func(const char *format, ...) {

	va_list arg;
	va_list arg2;
	const char *PEDAZO_TIMESTAMP_HEADER = "tiempo: %s; ";
	const char *HEADER =
	"archivo: %s; funcion: %s; linea %d; nivel: %zd caca 8====D ";
	char formato[CACA_LOG_MAX_TAM_CADENA + sizeof(HEADER)
	+ sizeof(PEDAZO_TIMESTAMP_HEADER)] = {'\0'};
	char pedazo_timestamp[sizeof(PEDAZO_TIMESTAMP_HEADER) + 100] = {'\0'};
	char cadena_timestamp[100] = {'\0'};

	caca_comun_timestamp(cadena_timestamp);
	sprintf(pedazo_timestamp, PEDAZO_TIMESTAMP_HEADER, cadena_timestamp);

	strcpy(formato, pedazo_timestamp);
	strcat(formato, HEADER);
	strcat(formato, format);
	strcat(formato, "\n");

	va_start(arg, format);
	va_copy(arg2, arg);
	vprintf(formato, arg2);
	va_end(arg2);
	va_end(arg);
	setbuf(stdout, NULL);
}
#endif

#ifdef CACA_COMUN_LOG
static char *caca_comun_arreglo_a_cadena(tipo_dato *arreglo, int tam_arreglo,
		char *buffer) {
	int i;
	char *ap_buffer = NULL;
	int characteres_escritos = 0;
#ifdef ONLINE_JUDGE
	return NULL;
#endif

	memset(buffer, 0, 100);
	ap_buffer = buffer;

	for (i = 0; i < tam_arreglo; i++) {
		characteres_escritos += sprintf(ap_buffer + characteres_escritos,
				"%12d", *(arreglo + i));
		if (i < tam_arreglo - 1) {
			*(ap_buffer + characteres_escritos++) = ',';
		}
	}
	*(ap_buffer + characteres_escritos) = '\0';
	return ap_buffer;
}

static char *caca_comun_arreglo_a_cadena_natural(natural *arreglo,
		natural tam_arreglo, char *buffer) {
	int i;
	char *ap_buffer = NULL;
	int characteres_escritos = 0;
#ifdef ONLINE_JUDGE
	return NULL;
#endif

	memset(buffer, 0, 100);
	ap_buffer = buffer;

	for (i = 0; i < tam_arreglo; i++) {
		characteres_escritos += sprintf(ap_buffer + characteres_escritos, "%2u",
				*(arreglo + i));
		if (i < tam_arreglo - 1) {
			*(ap_buffer + characteres_escritos++) = ',';
		}
	}
	*(ap_buffer + characteres_escritos) = '\0';
	return ap_buffer;
}
char *caca_comun_matrix_a_cadena(tipo_dato *matrix, natural filas_tam,
		natural columas_tam, char *buffer) {
	int i, j;
	natural inicio_buffer_act = 0;
	for (int i = 0; i < filas_tam; i++) {
		caca_comun_arreglo_a_cadena(matrix + i * columas_tam, columas_tam,
				buffer + inicio_buffer_act);
		inicio_buffer_act += strlen(buffer + inicio_buffer_act);
		buffer[inicio_buffer_act++] = '\n';
		/*		caca_log_debug("pero q mierda inicio buffer act %u %s",inicio_buffer_act,buffer);*/
	}
	return buffer;
}

static char *caca_comun_arreglo_a_cadena_entero_largo_sin_signo(
		entero_largo_sin_signo *arreglo, entero_largo_sin_signo tam_arreglo,
		char *buffer) {
	int i;
	char *ap_buffer = NULL;
	int characteres_escritos = 0;
#ifdef ONLINE_JUDGE
	return NULL;
#endif

	memset(buffer, 0, 100);
	ap_buffer = buffer;

	for (i = 0; i < tam_arreglo; i++) {
		characteres_escritos += sprintf(ap_buffer + characteres_escritos,
				"%llu", *(arreglo + i));
		if (i < tam_arreglo - 1) {
			*(ap_buffer + characteres_escritos++) = ',';
		}
	}
	*(ap_buffer + characteres_escritos) = '\0';
	return ap_buffer;
}
#else
static char *caca_comun_arreglo_a_cadena(tipo_dato *arreglo, int tam_arreglo,
		char *buffer) {
	return NULL;
}
static char *caca_comun_arreglo_a_cadena_natural(natural *arreglo,
		natural tam_arreglo, char *buffer) {
	return NULL;
}
char *caca_comun_matrix_a_cadena(tipo_dato *matrix, natural filas_tam,
		natural columas_tam, char *buffer) {
	return NULL;
}

static char *caca_comun_arreglo_a_cadena_entero_largo_sin_signo(
		entero_largo_sin_signo *arreglo, entero_largo_sin_signo tam_arreglo,
		char *buffer) {
	return NULL;
}
#endif
void caca_comun_strreplace(char s[], char chr, char repl_chr) {
	int i = 0;
	while (s[i] != '\0') {
		if (s[i] == chr) {
			s[i] = repl_chr;
		}
		i++;
	}
}

static int caca_comun_lee_matrix_long_stdin(tipo_dato *matrix, int *num_filas,
		int *num_columnas, int num_max_filas, int num_max_columnas) {
	int indice_filas = 0;
	int indice_columnas = 0;
	tipo_dato numero = 0;
	char *siguiente_cadena_numero = NULL;
	char *cadena_numero_actual = NULL;
	char *linea = NULL;

	linea = calloc(CACA_COMUN_TAM_MAX_LINEA, sizeof(char));

	while (indice_filas < num_max_filas
			&& fgets(linea, CACA_COMUN_TAM_MAX_LINEA, stdin)) {
		indice_columnas = 0;
		cadena_numero_actual = linea;
		caca_comun_strreplace(linea, '\n', '\0');
		if (!strlen(linea)) {
			caca_log_debug("weird, linea vacia");
			continue;
		}
		for (siguiente_cadena_numero = linea;; siguiente_cadena_numero =
				cadena_numero_actual) {
			numero = strtol(siguiente_cadena_numero, &cadena_numero_actual, 10);
			if (cadena_numero_actual == siguiente_cadena_numero) {
				break;
			}
			*(matrix + indice_filas * num_max_columnas + indice_columnas) =
					numero;
			indice_columnas++;
		}
		if (num_columnas) {
			num_columnas[indice_filas] = indice_columnas;
		}
		indice_filas++;
		caca_log_debug("las filas son %d, con clos %d", indice_filas,
				indice_columnas);
	}

	*num_filas = indice_filas;
	free(linea);
	return 0;
}

static inline natural caca_comun_cuenta_bitchs(tipo_dato num) {
	natural bitch_cnt = 0;
	tipo_dato num_mod = 0;
	num_mod = num;
	while (num_mod) {
		num_mod &= ~(num_mod & (-num_mod));
		bitch_cnt++;
	}
	return bitch_cnt;
}

static inline char caca_comun_letra_a_valor_minuscula(char letra) {
	return letra - 'a';
}

static inline natural caca_comun_max_natural(natural *nums, natural nums_tam) {
	natural max = 0;

	for (int i = 0; i < nums_tam; i++) {
		natural num_act = nums[i];
		if (num_act > max) {
			max = num_act;
		}
	}

	return max;
}

// XXX: https://stackoverflow.com/questions/122616/how-do-i-trim-leading-trailing-whitespace-in-a-standard-way?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa
static inline char *caca_comun_trimea(char *cad, natural cad_tam) {
	char c = cad[0];
	char tmp = '\0';
	natural i = 0;
	natural j = 0;

	caca_log_debug("entrada %s cad_tam %u", cad, cad_tam);
	while (j < cad_tam && cad[j] != '\0') {
		caca_log_debug("en j %u car %c", j, cad[j]);
		while (j < cad_tam && !isalpha(cad[j])) {
			caca_log_debug("brincando j %u car %c", j, cad[j]);
			j++;
		}
		caca_log_debug("aora j %u car %c", j, cad[j]);
		if (j == cad_tam) {
			caca_log_debug("q ped");
			break;
		}
		tmp = cad[i];
		cad[i] = cad[j];
		cad[j] = tmp;
		i++;
		j++;
	}
	caca_log_debug("mierda '%c'", cad[j]);

	i = 0;
	while (isalpha(cad[i++]))
		;
	caca_log_debug("salida %s", cad);
	cad[i - 1] = '\0';

	return cad;
}

#endif

#endif

#if 1
typedef struct numero_orden {
	int numero;
	natural posicion_inicial;
} numero_orden;

static int compara_numero_orden(const void *pa, const void *pb) {
	numero_orden *a = (numero_orden *) pa;
	numero_orden *b = (numero_orden *) pb;
	int r = 0;

	r = a->numero - b->numero;

	if (!r) {
		r = a->posicion_inicial - b->posicion_inicial;
	}

	assert(r);

	return r;
}

static inline natural *mapear_a_posicion_ordenada(natural *nums,
		natural nums_tam, natural *nums_res, natural nums_res_tam) {
	numero_orden *nums_ord = NULL;

	assert(nums_res_tam >= nums_tam);

	nums_ord = calloc(nums_tam, sizeof(numero_orden));
	assert(nums_ord);

	for (natural i = 0; i < nums_tam; i++) {
		numero_orden *num_ord_act = nums_ord + i;

		num_ord_act->numero = nums[i];
		num_ord_act->posicion_inicial = i;
	}

	qsort(nums_ord, nums_tam, sizeof(numero_orden), compara_numero_orden);

	for (natural i = 0; i < nums_tam; i++) {
		numero_orden *num_ord_act = nums_ord + i;
		nums_res[num_ord_act->posicion_inicial] = i;
	}

	free(nums_ord);
	return nums_res;
}
#endif

#if 1

#define BIT_CH_VALOR_INVALIDO ULLONG_MAX

typedef struct bit_ch {
	natural num_nodos_bit_ch;
	tipo_dato *nodos_bit_ch;
} bit_ch;

static inline void bit_ch_aumenta(bit_ch *bit, tipo_dato nuevo_valor,
		natural idx);

static inline void bit_ch_init(bit_ch *bit, tipo_dato valor_inicial,
		natural num_cacas) {
	tipo_dato *nodos = NULL;

	bit->num_nodos_bit_ch = num_cacas + 2;

	bit->nodos_bit_ch = calloc(bit->num_nodos_bit_ch, sizeof(tipo_dato));
	nodos = bit->nodos_bit_ch;

	nodos[0] = (tipo_dato) BIT_CH_VALOR_INVALIDO;
	for (natural i = 1; i < bit->num_nodos_bit_ch; i++) {
		nodos[i] = 0;
	}

	bit_ch_aumenta(bit, valor_inicial, 1);
}

static inline void bit_ch_fini(bit_ch *bit) {
	free(bit->nodos_bit_ch);
}

static inline void bit_ch_aumenta(bit_ch *bit, tipo_dato nuevo_valor,
		natural idx) {
	tipo_dato *nodos = bit->nodos_bit_ch;
	caca_log_debug("q verga actualizando %u con %d", idx, nuevo_valor);
	for (natural i = idx; i && i < bit->num_nodos_bit_ch; i += (i & (-i))) {
		caca_log_debug("actualizando caca %u con %d antes %d", i, nuevo_valor,
				nodos[i]);
		nodos[i] += nuevo_valor;
		caca_log_debug("actualizado caca %u aora %d", i, nodos[i]);
	}
}

static inline tipo_dato bit_ch_consulta(bit_ch *bit, natural idx) {
	tipo_dato *nodos = bit->nodos_bit_ch;
	tipo_dato res = 0;
	for (int i = idx; i > 0; i -= (i & (-i))) {
		assert_timeout(i < bit->num_nodos_bit_ch);
		caca_log_debug("consultando caca %u tiene %u", i, nodos[i]);
		res += nodos[i];
	}
	caca_log_debug("regresando %d", res);
	return res;
}

static inline tipo_dato bit_ch_consulta_rango_actualizacion_puntual(bit_ch *bit,
		natural i, natural j) {
	return bit_ch_consulta(bit, j) - bit_ch_consulta(bit, i - 1);
}

static inline tipo_dato bit_ch_consulta_fondo(bit_ch *bit, natural i) {
	return bit_ch_consulta_rango_actualizacion_puntual(bit, i,
			bit->num_nodos_bit_ch - 1);
}

static inline void bit_ch_aumenta_rango(bit_ch *bit, tipo_dato nuevo_valor,
		natural idx_ini, natural idx_fin) {
	caca_log_debug("aumentando de %u a %u con valor %llu", idx_ini, idx_fin,
			nuevo_valor);

	bit_ch_aumenta(bit, nuevo_valor, idx_ini);
	bit_ch_aumenta(bit, -nuevo_valor, idx_fin + 1);
}

static inline void bit_ch_aumenta_rango_consulta_rango(bit_ch *bit_puto,
		bit_ch *bit_aux, natural idx_ini, natural idx_fin,
		tipo_dato nuevo_valor) {

	caca_log_debug("aumentando de %u a %u con valor %llu para consulta rango",
			idx_ini, idx_fin, nuevo_valor);

	bit_ch_aumenta_rango(bit_puto, nuevo_valor, idx_ini, idx_fin);
	caca_log_debug(
			"actualizando para consulta rango inicial %d con %llu (%llu * %u)",
			idx_ini, nuevo_valor * (idx_ini - 1), nuevo_valor, idx_ini - 1);
	bit_ch_aumenta(bit_aux, nuevo_valor * (idx_ini - 1), idx_ini);
	caca_log_debug(
			"actualizando para consulta rango final %d con %llu(%llu,%u)",
			idx_fin + 1, -nuevo_valor * idx_fin, -nuevo_valor, idx_fin);
	bit_ch_aumenta(bit_aux, -nuevo_valor * idx_fin, idx_fin + 1);
}

static inline tipo_dato bit_ch_consulta_rango_actualizado_rango(
		bit_ch *bit_puto, bit_ch *bit_aux, natural idx) {
	tipo_dato resul = 0;
	tipo_dato valor_puto = 0;
	tipo_dato valor_aux = 0;

	valor_puto = bit_ch_consulta(bit_puto, idx);

	caca_log_debug("el valor putual en %u es %llu, aportara %llu (%llu * %u)",
			idx, valor_puto, valor_puto * idx, valor_puto, idx);

	valor_aux = bit_ch_consulta(bit_aux, idx);

	caca_log_debug("el valor aux en %u es %llu", idx, valor_puto);

	resul = valor_puto * idx - valor_aux;

	caca_log_debug("la suma acumulacaca hasta %u es %llu", idx, resul);

	return resul;
}

static inline tipo_dato bit_ch_consulta_rango(bit_ch *bit_puto, bit_ch *bit_aux,
		natural idx_ini, natural idx_fin) {
	tipo_dato resul = 0;
	tipo_dato resul_idx_ini = 0;
	tipo_dato resul_idx_fin = 0;

	resul_idx_ini = bit_ch_consulta_rango_actualizado_rango(bit_puto, bit_aux,
			idx_ini - 1);
	caca_log_debug("la suma acumulacaca ini hasta %u es %llu", idx_ini,
			resul_idx_ini);

	resul_idx_fin = bit_ch_consulta_rango_actualizado_rango(bit_puto, bit_aux,
			idx_fin);
	caca_log_debug("la suma acumulacaca fin hasta %u es %llu", idx_fin,
			resul_idx_fin);

	resul = resul_idx_fin - resul_idx_ini;

	caca_log_debug("la suma acumulacaca del rango %u-%u es %llu", idx_ini,
			idx_fin, resul);

	return resul;
}

#endif

static inline natural modifica(bit_ch *bi, bit_ch *bd, natural *a, natural i,
		bool quitar) {
	natural inv = 0;
	bit_ch *bm = NULL;
	int factor = 0;
	inv = bit_ch_consulta_fondo(bi, a[i] + 1) + bit_ch_consulta(bd, a[i] - 1);

	if (quitar) {
		bm = bd;
		factor = -1;
	} else {
		bm = bi;
		factor = 1;
	}
	caca_log_debug("el puto factor %d", factor);

	bit_ch_aumenta(bm, factor, a[i]);
	caca_log_debug("las inv al %s %u son %u", quitar?"quitar":"poner", a[i],
			inv);

	return inv;
}

static inline natural quita(bit_ch *bi, bit_ch *bd, natural *a, natural i) {
	return modifica(bi, bd, a, i, verdadero);
}

static inline natural anade(bit_ch *bi, bit_ch *bd, natural *a, natural i) {
	return modifica(bi, bd, a, i, falso);
}

static inline entero_largo_sin_signo core(natural *nums, natural nums_tam,
		entero_largo_sin_signo k) {
	entero_largo_sin_signo inv = 0;
	bit_ch *bi = caca_comun_calloc_local(bit_ch);
	bit_ch *bd = caca_comun_calloc_local(bit_ch);
	natural j = 0;
	entero_largo_sin_signo r = 0;
	natural *a = NULL;

	a = calloc(nums_tam, sizeof(natural));
	assert_timeout(a);

	mapear_a_posicion_ordenada(nums, nums_tam, a, nums_tam);
	for (natural i = 0; i < nums_tam; i++) {
		a[i]++;
	}
	caca_log_debug("mapeados %s",
			caca_comun_arreglo_a_cadena_natural(a, nums_tam, CACA_COMUN_BUF_STATICO));

	bit_ch_init(bi, 0, nums_tam);
	bit_ch_init(bd, 0, nums_tam);

	for (natural i = 0; i < nums_tam; i++) {
		inv += bit_ch_consulta_fondo(bd, a[i]);
		bit_ch_aumenta(bd, 1, a[i]);
		caca_log_debug("anadiendo %u en pos %u inv %llu", a[i], i, inv);
	}

	caca_log_debug("inv totales %llu", inv);

	inv += anade(bi, bd, a, 0);
	caca_log_debug("inv ini %llu", inv);
	for (natural i = 1; i < nums_tam; i++) {
		while (j < nums_tam && (j < i || inv > k)) {
			inv -= quita(bi, bd, a, j);
			j++;
			caca_log_debug("kitando %u en pos %u inv %llu", a[j-1], j-1, inv);
		}

		r += nums_tam - j;

		caca_log_debug("en %u %u inv %llu r %llu", i, j, inv, r)

		inv += anade(bi, bd, a, i);
	}

	bit_ch_fini(bi);
	bit_ch_fini(bd);

	return r;
}

#define MAX_CACA ((int)1E5)
natural a[MAX_CACA] = { 0 };

int main() {
	natural n = 0;
	entero_largo_sin_signo k = 0;

	scanf("%u %llu\n", &n, &k);
	assert_timeout(n<=MAX_CACA);
	assert_timeout(k < ((entero_largo_sin_signo )(1E18)));

	for (natural i = 0; i < n; i++) {
		scanf("%u", &a[i]);
	}

	printf("%llu\n", core(a, n, k));
	return EXIT_SUCCESS;
}


// XXX: http://codeforces.com/problemset/problem/220/E
#if 1
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <assert.h>
#include <stddef.h>
#include <unistd.h>
#include <sys/time.h>
#include <math.h>
#include <stdint.h>
#include <ctype.h>

#ifdef CACA_COMUN_LOG
#include <execinfo.h>
#endif

#ifdef __MACH__
#include <mach/clock.h>
#include <mach/mach.h>
#else
#include <time.h>
#include <stdarg.h>
#endif

#if 1
#ifndef LONG_LONG_MAX
#define LONG_LONG_MAX LONG_MAX
#endif

#define CACA_COMUN_TAM_MAX_LINEA (16*200000)
#define CACA_LOG_MAX_TAM_CADENA 2000

#define CACA_COMUN_BUF_STATICO (char[1000] ) { '\0' }

#define BITCH_VECTOR_NUM_BITS (sizeof(bitch_vector) * 8)

#define CACA_COMUN_ASSERT_DUROTE 0
#define CACA_COMUN_ASSERT_SUAVECITO 1
#define CACA_COMUN_ASSERT_NIMADRES 2

#define CACA_COMUN_VALOR_INVALIDO ((tipo_dato)UINT_MAX)
#define CACA_COMUN_IDX_INVALIDO ((natural)CACA_COMUN_VALOR_INVALIDO)
//#define CACA_COMUN_LOG

typedef unsigned int natural;
typedef int tipo_dato;
typedef long long entero_largo;
typedef unsigned long long entero_largo_sin_signo;
typedef long long bitch_vector;
typedef char byteme;

typedef enum BOOLEANOS {
	falso = 0, verdadero
} bool;

/*
 #define CACA_COMUN_TIPO_ASSERT CACA_COMUN_ASSERT_SUAVECITO
 #define CACA_COMUN_TIPO_ASSERT CACA_COMUN_ASSERT_NIMADRES
 */
#define CACA_COMUN_TIPO_ASSERT CACA_COMUN_ASSERT_DUROTE

#define assert_timeout_dummy(condition) 0;

#if CACA_COMUN_TIPO_ASSERT == CACA_COMUN_ASSERT_DUROTE
#define assert_timeout(condition) assert(condition);
#endif
#if CACA_COMUN_TIPO_ASSERT == CACA_COMUN_ASSERT_SUAVECITO
#define assert_timeout(condition) if(!(condition)){while(1){printf("");};abort();}
#endif
#if CACA_COMUN_TIPO_ASSERT == CACA_COMUN_ASSERT_NIMADRES
#define assert_timeout(condition) 0
#endif

#ifdef CACA_COMUN_LOG
#define caca_log_debug(formato, args...) \
		do \
		{ \
			size_t profundidad = 0; \
			void *array[CACA_LOG_MAX_TAM_CADENA]; \
 			profundidad = backtrace(array, CACA_LOG_MAX_TAM_CADENA); \
			caca_log_debug_func(formato,__FILE__, __func__, __LINE__,profundidad,##args); \
		} \
		while(0);
#else
#define caca_log_debug(formato, args...) 0;
#endif

#define caca_comun_max(x,y) ((x) < (y) ? (y) : (x))
#define caca_comun_min(x,y) ((x) < (y) ? (x) : (y))

#define caca_comun_calloc_local(tipo) (&(tipo){0})

void caca_log_debug_func(const char *format, ...);

void caca_comun_current_utc_time(struct timespec *ts) {

#ifdef __MACH__
	clock_serv_t cclock;
	mach_timespec_t mts;
	host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
	clock_get_time(cclock, &mts);
	mach_port_deallocate(mach_task_self(), cclock);
	ts->tv_sec = mts.tv_sec;
	ts->tv_nsec = mts.tv_nsec;
#else
#ifdef CACA_COMUN_LOG
	clock_gettime(CLOCK_REALTIME, ts);
#endif
#endif

}

void caca_comun_timestamp(char *stime) {
	time_t ltime;
	struct tm result;
	long ms;
#ifndef ONLINE_JUDGE
	struct timespec spec;
#endif
	char parte_milisecundos[50];

	ltime = time(NULL);

#ifndef ONLINE_JUDGE
	localtime_r(&ltime, &result);
	asctime_r(&result, stime);
#endif

	*(stime + strlen(stime) - 1) = ' ';

#ifndef ONLINE_JUDGE
	caca_comun_current_utc_time(&spec);
	ms = round(spec.tv_nsec / 1.0e3);
#endif
	sprintf(parte_milisecundos, "%ld", ms);
	strcat(stime, parte_milisecundos);
}
#ifdef CACA_COMUN_LOG
void caca_log_debug_func(const char *format, ...) {

	va_list arg;
	va_list arg2;
	const char *PEDAZO_TIMESTAMP_HEADER = "tiempo: %s; ";
	const char *HEADER =
	"archivo: %s; funcion: %s; linea %d; nivel: %zd caca 8====D ";
	char formato[CACA_LOG_MAX_TAM_CADENA + sizeof(HEADER)
	+ sizeof(PEDAZO_TIMESTAMP_HEADER)] = {'\0'};
	char pedazo_timestamp[sizeof(PEDAZO_TIMESTAMP_HEADER) + 100] = {'\0'};
	char cadena_timestamp[100] = {'\0'};

	caca_comun_timestamp(cadena_timestamp);
	sprintf(pedazo_timestamp, PEDAZO_TIMESTAMP_HEADER, cadena_timestamp);

	strcpy(formato, pedazo_timestamp);
	strcat(formato, HEADER);
	strcat(formato, format);
	strcat(formato, "\n");

	va_start(arg, format);
	va_copy(arg2, arg);
	vprintf(formato, arg2);
	va_end(arg2);
	va_end(arg);
	setbuf(stdout, NULL);
}
#endif

#ifdef CACA_COMUN_LOG
static char *caca_comun_arreglo_a_cadena(tipo_dato *arreglo, int tam_arreglo,
		char *buffer) {
	int i;
	char *ap_buffer = NULL;
	int characteres_escritos = 0;
#ifdef ONLINE_JUDGE
	return NULL;
#endif

	memset(buffer, 0, 100);
	ap_buffer = buffer;

	for (i = 0; i < tam_arreglo; i++) {
		characteres_escritos += sprintf(ap_buffer + characteres_escritos,
				"%12d", *(arreglo + i));
		if (i < tam_arreglo - 1) {
			*(ap_buffer + characteres_escritos++) = ',';
		}
	}
	*(ap_buffer + characteres_escritos) = '\0';
	return ap_buffer;
}

static char *caca_comun_arreglo_a_cadena_natural(natural *arreglo,
		natural tam_arreglo, char *buffer) {
	int i;
	char *ap_buffer = NULL;
	int characteres_escritos = 0;
#ifdef ONLINE_JUDGE
	return NULL;
#endif

	memset(buffer, 0, 100);
	ap_buffer = buffer;

	for (i = 0; i < tam_arreglo; i++) {
		characteres_escritos += sprintf(ap_buffer + characteres_escritos, "%2u",
				*(arreglo + i));
		if (i < tam_arreglo - 1) {
			*(ap_buffer + characteres_escritos++) = ',';
		}
	}
	*(ap_buffer + characteres_escritos) = '\0';
	return ap_buffer;
}
char *caca_comun_matrix_a_cadena(tipo_dato *matrix, natural filas_tam,
		natural columas_tam, char *buffer) {
	int i, j;
	natural inicio_buffer_act = 0;
	for (int i = 0; i < filas_tam; i++) {
		caca_comun_arreglo_a_cadena(matrix + i * columas_tam, columas_tam,
				buffer + inicio_buffer_act);
		inicio_buffer_act += strlen(buffer + inicio_buffer_act);
		buffer[inicio_buffer_act++] = '\n';
		/*		caca_log_debug("pero q mierda inicio buffer act %u %s",inicio_buffer_act,buffer);*/
	}
	return buffer;
}

static char *caca_comun_arreglo_a_cadena_entero_largo_sin_signo(
		entero_largo_sin_signo *arreglo, entero_largo_sin_signo tam_arreglo,
		char *buffer) {
	int i;
	char *ap_buffer = NULL;
	int characteres_escritos = 0;
#ifdef ONLINE_JUDGE
	return NULL;
#endif

	memset(buffer, 0, 100);
	ap_buffer = buffer;

	for (i = 0; i < tam_arreglo; i++) {
		characteres_escritos += sprintf(ap_buffer + characteres_escritos,
				"%2I64d", *(arreglo + i));
		if (i < tam_arreglo - 1) {
			*(ap_buffer + characteres_escritos++) = ',';
		}
	}
	*(ap_buffer + characteres_escritos) = '\0';
	return ap_buffer;
}
#else
static char *caca_comun_arreglo_a_cadena(tipo_dato *arreglo, int tam_arreglo,
		char *buffer) {
	return NULL;
}
static char *caca_comun_arreglo_a_cadena_natural(natural *arreglo,
		natural tam_arreglo, char *buffer) {
	return NULL;
}
char *caca_comun_matrix_a_cadena(tipo_dato *matrix, natural filas_tam,
		natural columas_tam, char *buffer) {
	return NULL;
}

static char *caca_comun_arreglo_a_cadena_entero_largo_sin_signo(
		entero_largo_sin_signo *arreglo, entero_largo_sin_signo tam_arreglo,
		char *buffer) {
	return NULL;
}
#endif
void caca_comun_strreplace(char s[], char chr, char repl_chr) {
	int i = 0;
	while (s[i] != '\0') {
		if (s[i] == chr) {
			s[i] = repl_chr;
		}
		i++;
	}
}

static int caca_comun_lee_matrix_long_stdin(tipo_dato *matrix, int *num_filas,
		int *num_columnas, int num_max_filas, int num_max_columnas) {
	int indice_filas = 0;
	int indice_columnas = 0;
	tipo_dato numero = 0;
	char *siguiente_cadena_numero = NULL;
	char *cadena_numero_actual = NULL;
	char *linea = NULL;

	linea = calloc(CACA_COMUN_TAM_MAX_LINEA, sizeof(char));

	while (indice_filas < num_max_filas
			&& fgets(linea, CACA_COMUN_TAM_MAX_LINEA, stdin)) {
		indice_columnas = 0;
		cadena_numero_actual = linea;
		caca_comun_strreplace(linea, '\n', '\0');
		if (!strlen(linea)) {
			caca_log_debug("weird, linea vacia");
			continue;
		}
		for (siguiente_cadena_numero = linea;; siguiente_cadena_numero =
				cadena_numero_actual) {
			numero = strtol(siguiente_cadena_numero, &cadena_numero_actual, 10);
			if (cadena_numero_actual == siguiente_cadena_numero) {
				break;
			}
			*(matrix + indice_filas * num_max_columnas + indice_columnas) =
					numero;
			indice_columnas++;
		}
		if (num_columnas) {
			num_columnas[indice_filas] = indice_columnas;
		}
		indice_filas++;
		caca_log_debug("las filas son %d, con clos %d", indice_filas,
				indice_columnas);
	}

	*num_filas = indice_filas;
	free(linea);
	return 0;
}

static inline natural caca_comun_cuenta_bitchs(tipo_dato num) {
	natural bitch_cnt = 0;
	tipo_dato num_mod = 0;
	num_mod = num;
	while (num_mod) {
		num_mod &= ~(num_mod & (-num_mod));
		bitch_cnt++;
	}
	return bitch_cnt;
}

static inline char caca_comun_letra_a_valor_minuscula(char letra) {
	return letra - 'a';
}

static inline natural caca_comun_max_natural(natural *nums, natural nums_tam) {
	natural max = 0;

	for (int i = 0; i < nums_tam; i++) {
		natural num_act = nums[i];
		if (num_act > max) {
			max = num_act;
		}
	}

	return max;
}

// XXX: https://stackoverflow.com/questions/122616/how-do-i-trim-leading-trailing-whitespace-in-a-standard-way?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa
static inline char *caca_comun_trimea(char *cad, natural cad_tam) {
	char c = cad[0];
	char tmp = '\0';
	natural i = 0;
	natural j = 0;

	caca_log_debug("entrada %s cad_tam %u", cad, cad_tam);
	while (j < cad_tam && cad[j] != '\0') {
		caca_log_debug("en j %u car %c", j, cad[j]);
		while (j < cad_tam && !isalpha(cad[j])) {
			caca_log_debug("brincando j %u car %c", j, cad[j]);
			j++;
		}
		caca_log_debug("aora j %u car %c", j, cad[j]);
		if (j == cad_tam) {
			caca_log_debug("q ped");
			break;
		}
		tmp = cad[i];
		cad[i] = cad[j];
		cad[j] = tmp;
		i++;
		j++;
	}
	caca_log_debug("mierda '%c'", cad[j]);

	i = 0;
	while (isalpha(cad[i++]))
		;
	caca_log_debug("salida %s", cad);
	cad[i - 1] = '\0';

	return cad;
}

#endif

#endif

#if 1
typedef struct numero_orden {
	int numero;
	natural posicion_inicial;
} numero_orden;

static int compara_numero_orden(const void *pa, const void *pb) {
	numero_orden *a = (numero_orden *) pa;
	numero_orden *b = (numero_orden *) pb;
	int r = 0;

	r = a->numero - b->numero;

	if (!r) {
		r = a->posicion_inicial - b->posicion_inicial;
	}

	assert(r);

	return r;
}

static inline natural *mapear_a_posicion_ordenada(natural *nums,
		natural nums_tam, natural *nums_res, natural nums_res_tam) {
	numero_orden *nums_ord = NULL;

	assert(nums_res_tam >= nums_tam);

	nums_ord = calloc(nums_tam, sizeof(numero_orden));
	assert(nums_ord);

	for (natural i = 0; i < nums_tam; i++) {
		numero_orden *num_ord_act = nums_ord + i;

		num_ord_act->numero = nums[i];
		num_ord_act->posicion_inicial = i;
	}

	qsort(nums_ord, nums_tam, sizeof(numero_orden), compara_numero_orden);

	for (natural i = 0; i < nums_tam; i++) {
		numero_orden *num_ord_act = nums_ord + i;
		nums_res[num_ord_act->posicion_inicial] = i;
	}

	free(nums_ord);
	return nums_res;
}
#endif

#if 1

#define BIT_CH_VALOR_INVALIDO ULLONG_MAX

typedef struct bit_ch {
	natural num_nodos_bit_ch;
	tipo_dato *nodos_bit_ch;
} bit_ch;

static inline void bit_ch_aumenta(bit_ch *bit, tipo_dato nuevo_valor,
		natural idx);

static inline void bit_ch_init(bit_ch *bit, tipo_dato valor_inicial,
		natural num_cacas) {
	tipo_dato *nodos = NULL;

	bit->num_nodos_bit_ch = num_cacas + 2;

	bit->nodos_bit_ch = calloc(bit->num_nodos_bit_ch, sizeof(tipo_dato));
	nodos = bit->nodos_bit_ch;

	nodos[0] = (tipo_dato) BIT_CH_VALOR_INVALIDO;
	for (natural i = 1; i < bit->num_nodos_bit_ch; i++) {
		nodos[i] = 0;
	}

	bit_ch_aumenta(bit, valor_inicial, 1);
}

static inline void bit_ch_fini(bit_ch *bit) {
	free(bit->nodos_bit_ch);
}

static inline void bit_ch_aumenta(bit_ch *bit, tipo_dato nuevo_valor,
		natural idx) {
	tipo_dato *nodos = bit->nodos_bit_ch;
	caca_log_debug("q verga actualizando %u con %d", idx, nuevo_valor);
	for (natural i = idx; i && i <= bit->num_nodos_bit_ch; i += (i & (-i))) {
		caca_log_debug("actualizando caca %u con %d antes %d", i, nuevo_valor,
				nodos[i]);
		nodos[i] += nuevo_valor;
		caca_log_debug("actualizado caca %u aora %d", i, nodos[i]);
	}
}

static inline tipo_dato bit_ch_consulta(bit_ch *bit, natural idx) {
	tipo_dato *nodos = bit->nodos_bit_ch;
	tipo_dato res = 0;
	for (int i = idx; i > 0; i -= (i & (-i))) {
		assert_timeout(i < bit->num_nodos_bit_ch);
		caca_log_debug("consultando caca %u tiene %u", i, nodos[i]);
		res += nodos[i];
	}
	caca_log_debug("regresando %d", res);
	return res;
}

static inline tipo_dato bit_ch_consulta_rango_actualizacion_puntual(bit_ch *bit,
		natural i, natural j) {
	return bit_ch_consulta(bit, j) - bit_ch_consulta(bit, i - 1);
}

static inline tipo_dato bit_ch_consulta_fondo(bit_ch *bit, natural i) {
	return bit_ch_consulta_rango_actualizacion_puntual(bit, i,
			bit->num_nodos_bit_ch - 1);
}

static inline void bit_ch_aumenta_rango(bit_ch *bit, tipo_dato nuevo_valor,
		natural idx_ini, natural idx_fin) {
	caca_log_debug("aumentando de %u a %u con valor %I64d", idx_ini, idx_fin,
			nuevo_valor);

	bit_ch_aumenta(bit, nuevo_valor, idx_ini);
	bit_ch_aumenta(bit, -nuevo_valor, idx_fin + 1);
}

static inline void bit_ch_aumenta_rango_consulta_rango(bit_ch *bit_puto,
		bit_ch *bit_aux, natural idx_ini, natural idx_fin,
		tipo_dato nuevo_valor) {

	caca_log_debug("aumentando de %u a %u con valor %I64d para consulta rango",
			idx_ini, idx_fin, nuevo_valor);

	bit_ch_aumenta_rango(bit_puto, nuevo_valor, idx_ini, idx_fin);
	caca_log_debug(
			"actualizando para consulta rango inicial %d con %I64d (%I64d * %u)",
			idx_ini, nuevo_valor * (idx_ini - 1), nuevo_valor, idx_ini - 1);
	bit_ch_aumenta(bit_aux, nuevo_valor * (idx_ini - 1), idx_ini);
	caca_log_debug(
			"actualizando para consulta rango final %d con %I64d(%I64d,%u)",
			idx_fin + 1, -nuevo_valor * idx_fin, -nuevo_valor, idx_fin);
	bit_ch_aumenta(bit_aux, -nuevo_valor * idx_fin, idx_fin + 1);
}

static inline tipo_dato bit_ch_consulta_rango_actualizado_rango(
		bit_ch *bit_puto, bit_ch *bit_aux, natural idx) {
	tipo_dato resul = 0;
	tipo_dato valor_puto = 0;
	tipo_dato valor_aux = 0;

	valor_puto = bit_ch_consulta(bit_puto, idx);

	caca_log_debug("el valor putual en %u es %I64d, aportara %I64d (%I64d * %u)",
			idx, valor_puto, valor_puto * idx, valor_puto, idx);

	valor_aux = bit_ch_consulta(bit_aux, idx);

	caca_log_debug("el valor aux en %u es %I64d", idx, valor_puto);

	resul = valor_puto * idx - valor_aux;

	caca_log_debug("la suma acumulacaca hasta %u es %I64d", idx, resul);

	return resul;
}

static inline tipo_dato bit_ch_consulta_rango(bit_ch *bit_puto, bit_ch *bit_aux,
		natural idx_ini, natural idx_fin) {
	tipo_dato resul = 0;
	tipo_dato resul_idx_ini = 0;
	tipo_dato resul_idx_fin = 0;

	resul_idx_ini = bit_ch_consulta_rango_actualizado_rango(bit_puto, bit_aux,
			idx_ini - 1);
	caca_log_debug("la suma acumulacaca ini hasta %u es %I64d", idx_ini,
			resul_idx_ini);

	resul_idx_fin = bit_ch_consulta_rango_actualizado_rango(bit_puto, bit_aux,
			idx_fin);
	caca_log_debug("la suma acumulacaca fin hasta %u es %I64d", idx_fin,
			resul_idx_fin);

	resul = resul_idx_fin - resul_idx_ini;

	caca_log_debug("la suma acumulacaca del rango %u-%u es %I64d", idx_ini,
			idx_fin, resul);

	return resul;
}

#endif

static inline natural modifica(bit_ch *bi, bit_ch *bd, natural *a, natural i,
		bool quitar) {
	natural inv = 0;
	bit_ch *bm = NULL;
	int factor = 0;
	inv = bit_ch_consulta_fondo(bi, a[i] + 1) + bit_ch_consulta(bd, a[i] - 1);

	if (quitar) {
		bm = bd;
		factor = -1;
	} else {
		bm = bi;
		factor = 1;
	}
	caca_log_debug("el puto factor %d", factor);

	bit_ch_aumenta(bm, factor, a[i]);
	caca_log_debug("las inv al %s %u son %u", quitar?"quitar":"poner", a[i],
			inv);

	return inv;
}

static inline natural quita(bit_ch *bi, bit_ch *bd, natural *a, natural i) {
	return modifica(bi, bd, a, i, verdadero);
}

static inline natural anade(bit_ch *bi, bit_ch *bd, natural *a, natural i) {
	return modifica(bi, bd, a, i, falso);
}

static inline entero_largo_sin_signo core(natural *nums, natural nums_tam,
		entero_largo_sin_signo k) {
	entero_largo_sin_signo inv = 0;
	bit_ch *bi = caca_comun_calloc_local(bit_ch);
	bit_ch *bd = caca_comun_calloc_local(bit_ch);
	natural j = 0;
	entero_largo_sin_signo r = 0;
	natural *a = NULL;

	a = calloc(nums_tam, sizeof(natural));
	assert_timeout(a);

	mapear_a_posicion_ordenada(nums, nums_tam, a, nums_tam);
	for (natural i = 0; i < nums_tam; i++) {
		a[i]++;
	}
	caca_log_debug("mapeados %s",
			caca_comun_arreglo_a_cadena_natural(a, nums_tam, CACA_COMUN_BUF_STATICO));

	bit_ch_init(bi, 0, nums_tam);
	bit_ch_init(bd, 0, nums_tam);

	for (natural i = 0; i < nums_tam; i++) {
		caca_log_debug("anadiendo %u en pos %u", a[i], i);
		inv += bit_ch_consulta_fondo(bd, a[i]);
		bit_ch_aumenta(bd, 1, a[i]);
	}

	caca_log_debug("inv totales %I64d", inv);

	anade(bi, bd, a, 0);
	for (natural i = 1; i < nums_tam; i++) {
		while (j < nums_tam && (j < i || inv > k)) {
			inv -= quita(bi, bd, a, j);
			j++;
			caca_log_debug("kitando %u en pos %u inv %I64d", a[j-1], j-1, inv);
		}

		r += nums_tam - j;

		caca_log_debug("en %u %u inv %I64d r %I64d", i, j, inv, r)

		inv += anade(bi, bd, a, i);
	}

	bit_ch_fini(bi);
	bit_ch_fini(bd);

	return r;
}

#define MAX_CACA ((int)1E5)
natural a[MAX_CACA] = { 0 };

int main() {
	natural n = 0;
	natural k = 0;

	scanf("%u %u\n", &n, &k);

	for (natural i = 0; i < n; i++) {
		scanf("%u", a + i);
	}

	printf("%I64d\n", core(a, n, k));
	return EXIT_SUCCESS;
}


// XXX: http://codeforces.com/problemset/problem/220/E
#if 1
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <assert.h>
#include <stddef.h>
#include <unistd.h>
#include <sys/time.h>
#include <math.h>
#include <stdint.h>
#include <ctype.h>

#ifdef CACA_COMUN_LOG
#include <execinfo.h>
#endif

#ifdef __MACH__
#include <mach/clock.h>
#include <mach/mach.h>
#else
#include <time.h>
#include <stdarg.h>
#endif

#if 1
#ifndef LONG_LONG_MAX
#define LONG_LONG_MAX LONG_MAX
#endif

#define CACA_COMUN_TAM_MAX_LINEA (16*200000)
#define CACA_LOG_MAX_TAM_CADENA 2000

#define CACA_COMUN_BUF_STATICO (char[1000] ) { '\0' }

#define BITCH_VECTOR_NUM_BITS (sizeof(bitch_vector) * 8)

#define CACA_COMUN_ASSERT_DUROTE 0
#define CACA_COMUN_ASSERT_SUAVECITO 1
#define CACA_COMUN_ASSERT_NIMADRES 2

#define CACA_COMUN_VALOR_INVALIDO ((tipo_dato)UINT_MAX)
#define CACA_COMUN_IDX_INVALIDO ((natural)CACA_COMUN_VALOR_INVALIDO)
//#define CACA_COMUN_LOG

typedef unsigned int natural;
typedef int tipo_dato;
typedef long long entero_largo;
typedef unsigned long long entero_largo_sin_signo;
typedef long long bitch_vector;
typedef char byteme;

typedef enum BOOLEANOS {
	falso = 0, verdadero
} bool;

/*
 #define CACA_COMUN_TIPO_ASSERT CACA_COMUN_ASSERT_SUAVECITO
 #define CACA_COMUN_TIPO_ASSERT CACA_COMUN_ASSERT_NIMADRES
 */
#define CACA_COMUN_TIPO_ASSERT CACA_COMUN_ASSERT_DUROTE

#define assert_timeout_dummy(condition) 0;

#if CACA_COMUN_TIPO_ASSERT == CACA_COMUN_ASSERT_DUROTE
#define assert_timeout(condition) assert(condition);
#endif
#if CACA_COMUN_TIPO_ASSERT == CACA_COMUN_ASSERT_SUAVECITO
#define assert_timeout(condition) if(!(condition)){while(1){printf("");};abort();}
#endif
#if CACA_COMUN_TIPO_ASSERT == CACA_COMUN_ASSERT_NIMADRES
#define assert_timeout(condition) 0
#endif

#ifdef CACA_COMUN_LOG
#define caca_log_debug(formato, args...) \
		do \
		{ \
			size_t profundidad = 0; \
			void *array[CACA_LOG_MAX_TAM_CADENA]; \
 			profundidad = backtrace(array, CACA_LOG_MAX_TAM_CADENA); \
			caca_log_debug_func(formato,__FILE__, __func__, __LINE__,profundidad,##args); \
		} \
		while(0);
#else
#define caca_log_debug(formato, args...) 0;
#endif

#define caca_comun_max(x,y) ((x) < (y) ? (y) : (x))
#define caca_comun_min(x,y) ((x) < (y) ? (x) : (y))

#define caca_comun_calloc_local(tipo) (&(tipo){0})

void caca_log_debug_func(const char *format, ...);

void caca_comun_current_utc_time(struct timespec *ts) {

#ifdef __MACH__
	clock_serv_t cclock;
	mach_timespec_t mts;
	host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
	clock_get_time(cclock, &mts);
	mach_port_deallocate(mach_task_self(), cclock);
	ts->tv_sec = mts.tv_sec;
	ts->tv_nsec = mts.tv_nsec;
#else
#ifdef CACA_COMUN_LOG
	clock_gettime(CLOCK_REALTIME, ts);
#endif
#endif

}

void caca_comun_timestamp(char *stime) {
	time_t ltime;
	struct tm result;
	long ms;
#ifndef ONLINE_JUDGE
	struct timespec spec;
#endif
	char parte_milisecundos[50];

	ltime = time(NULL);

#ifndef ONLINE_JUDGE
	localtime_r(&ltime, &result);
	asctime_r(&result, stime);
#endif

	*(stime + strlen(stime) - 1) = ' ';

#ifndef ONLINE_JUDGE
	caca_comun_current_utc_time(&spec);
	ms = round(spec.tv_nsec / 1.0e3);
#endif
	sprintf(parte_milisecundos, "%ld", ms);
	strcat(stime, parte_milisecundos);
}
#ifdef CACA_COMUN_LOG
void caca_log_debug_func(const char *format, ...) {

	va_list arg;
	va_list arg2;
	const char *PEDAZO_TIMESTAMP_HEADER = "tiempo: %s; ";
	const char *HEADER =
	"archivo: %s; funcion: %s; linea %d; nivel: %zd caca 8====D ";
	char formato[CACA_LOG_MAX_TAM_CADENA + sizeof(HEADER)
	+ sizeof(PEDAZO_TIMESTAMP_HEADER)] = {'\0'};
	char pedazo_timestamp[sizeof(PEDAZO_TIMESTAMP_HEADER) + 100] = {'\0'};
	char cadena_timestamp[100] = {'\0'};

	caca_comun_timestamp(cadena_timestamp);
	sprintf(pedazo_timestamp, PEDAZO_TIMESTAMP_HEADER, cadena_timestamp);

	strcpy(formato, pedazo_timestamp);
	strcat(formato, HEADER);
	strcat(formato, format);
	strcat(formato, "\n");

	va_start(arg, format);
	va_copy(arg2, arg);
	vprintf(formato, arg2);
	va_end(arg2);
	va_end(arg);
	setbuf(stdout, NULL);
}
#endif

#ifdef CACA_COMUN_LOG
static char *caca_comun_arreglo_a_cadena(tipo_dato *arreglo, int tam_arreglo,
		char *buffer) {
	int i;
	char *ap_buffer = NULL;
	int characteres_escritos = 0;
#ifdef ONLINE_JUDGE
	return NULL;
#endif

	memset(buffer, 0, 100);
	ap_buffer = buffer;

	for (i = 0; i < tam_arreglo; i++) {
		characteres_escritos += sprintf(ap_buffer + characteres_escritos,
				"%12d", *(arreglo + i));
		if (i < tam_arreglo - 1) {
			*(ap_buffer + characteres_escritos++) = ',';
		}
	}
	*(ap_buffer + characteres_escritos) = '\0';
	return ap_buffer;
}

static char *caca_comun_arreglo_a_cadena_natural(natural *arreglo,
		natural tam_arreglo, char *buffer) {
	int i;
	char *ap_buffer = NULL;
	int characteres_escritos = 0;
#ifdef ONLINE_JUDGE
	return NULL;
#endif

	memset(buffer, 0, 100);
	ap_buffer = buffer;

	for (i = 0; i < tam_arreglo; i++) {
		characteres_escritos += sprintf(ap_buffer + characteres_escritos, "%2u",
				*(arreglo + i));
		if (i < tam_arreglo - 1) {
			*(ap_buffer + characteres_escritos++) = ',';
		}
	}
	*(ap_buffer + characteres_escritos) = '\0';
	return ap_buffer;
}
char *caca_comun_matrix_a_cadena(tipo_dato *matrix, natural filas_tam,
		natural columas_tam, char *buffer) {
	int i, j;
	natural inicio_buffer_act = 0;
	for (int i = 0; i < filas_tam; i++) {
		caca_comun_arreglo_a_cadena(matrix + i * columas_tam, columas_tam,
				buffer + inicio_buffer_act);
		inicio_buffer_act += strlen(buffer + inicio_buffer_act);
		buffer[inicio_buffer_act++] = '\n';
		/*		caca_log_debug("pero q mierda inicio buffer act %u %s",inicio_buffer_act,buffer);*/
	}
	return buffer;
}

static char *caca_comun_arreglo_a_cadena_entero_largo_sin_signo(
		entero_largo_sin_signo *arreglo, entero_largo_sin_signo tam_arreglo,
		char *buffer) {
	int i;
	char *ap_buffer = NULL;
	int characteres_escritos = 0;
#ifdef ONLINE_JUDGE
	return NULL;
#endif

	memset(buffer, 0, 100);
	ap_buffer = buffer;

	for (i = 0; i < tam_arreglo; i++) {
		characteres_escritos += sprintf(ap_buffer + characteres_escritos,
				"%2I64d", *(arreglo + i));
		if (i < tam_arreglo - 1) {
			*(ap_buffer + characteres_escritos++) = ',';
		}
	}
	*(ap_buffer + characteres_escritos) = '\0';
	return ap_buffer;
}
#else
static char *caca_comun_arreglo_a_cadena(tipo_dato *arreglo, int tam_arreglo,
		char *buffer) {
	return NULL;
}
static char *caca_comun_arreglo_a_cadena_natural(natural *arreglo,
		natural tam_arreglo, char *buffer) {
	return NULL;
}
char *caca_comun_matrix_a_cadena(tipo_dato *matrix, natural filas_tam,
		natural columas_tam, char *buffer) {
	return NULL;
}

static char *caca_comun_arreglo_a_cadena_entero_largo_sin_signo(
		entero_largo_sin_signo *arreglo, entero_largo_sin_signo tam_arreglo,
		char *buffer) {
	return NULL;
}
#endif
void caca_comun_strreplace(char s[], char chr, char repl_chr) {
	int i = 0;
	while (s[i] != '\0') {
		if (s[i] == chr) {
			s[i] = repl_chr;
		}
		i++;
	}
}

static int caca_comun_lee_matrix_long_stdin(tipo_dato *matrix, int *num_filas,
		int *num_columnas, int num_max_filas, int num_max_columnas) {
	int indice_filas = 0;
	int indice_columnas = 0;
	tipo_dato numero = 0;
	char *siguiente_cadena_numero = NULL;
	char *cadena_numero_actual = NULL;
	char *linea = NULL;

	linea = calloc(CACA_COMUN_TAM_MAX_LINEA, sizeof(char));

	while (indice_filas < num_max_filas
			&& fgets(linea, CACA_COMUN_TAM_MAX_LINEA, stdin)) {
		indice_columnas = 0;
		cadena_numero_actual = linea;
		caca_comun_strreplace(linea, '\n', '\0');
		if (!strlen(linea)) {
			caca_log_debug("weird, linea vacia");
			continue;
		}
		for (siguiente_cadena_numero = linea;; siguiente_cadena_numero =
				cadena_numero_actual) {
			numero = strtol(siguiente_cadena_numero, &cadena_numero_actual, 10);
			if (cadena_numero_actual == siguiente_cadena_numero) {
				break;
			}
			*(matrix + indice_filas * num_max_columnas + indice_columnas) =
					numero;
			indice_columnas++;
		}
		if (num_columnas) {
			num_columnas[indice_filas] = indice_columnas;
		}
		indice_filas++;
		caca_log_debug("las filas son %d, con clos %d", indice_filas,
				indice_columnas);
	}

	*num_filas = indice_filas;
	free(linea);
	return 0;
}

static inline natural caca_comun_cuenta_bitchs(tipo_dato num) {
	natural bitch_cnt = 0;
	tipo_dato num_mod = 0;
	num_mod = num;
	while (num_mod) {
		num_mod &= ~(num_mod & (-num_mod));
		bitch_cnt++;
	}
	return bitch_cnt;
}

static inline char caca_comun_letra_a_valor_minuscula(char letra) {
	return letra - 'a';
}

static inline natural caca_comun_max_natural(natural *nums, natural nums_tam) {
	natural max = 0;

	for (int i = 0; i < nums_tam; i++) {
		natural num_act = nums[i];
		if (num_act > max) {
			max = num_act;
		}
	}

	return max;
}

// XXX: https://stackoverflow.com/questions/122616/how-do-i-trim-leading-trailing-whitespace-in-a-standard-way?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa
static inline char *caca_comun_trimea(char *cad, natural cad_tam) {
	char c = cad[0];
	char tmp = '\0';
	natural i = 0;
	natural j = 0;

	caca_log_debug("entrada %s cad_tam %u", cad, cad_tam);
	while (j < cad_tam && cad[j] != '\0') {
		caca_log_debug("en j %u car %c", j, cad[j]);
		while (j < cad_tam && !isalpha(cad[j])) {
			caca_log_debug("brincando j %u car %c", j, cad[j]);
			j++;
		}
		caca_log_debug("aora j %u car %c", j, cad[j]);
		if (j == cad_tam) {
			caca_log_debug("q ped");
			break;
		}
		tmp = cad[i];
		cad[i] = cad[j];
		cad[j] = tmp;
		i++;
		j++;
	}
	caca_log_debug("mierda '%c'", cad[j]);

	i = 0;
	while (isalpha(cad[i++]))
		;
	caca_log_debug("salida %s", cad);
	cad[i - 1] = '\0';

	return cad;
}

#endif

#endif

#if 1
typedef struct numero_orden {
	int numero;
	natural posicion_inicial;
} numero_orden;

static int compara_numero_orden(const void *pa, const void *pb) {
	numero_orden *a = (numero_orden *) pa;
	numero_orden *b = (numero_orden *) pb;
	int r = 0;

	r = a->numero - b->numero;

	if (!r) {
		r = a->posicion_inicial - b->posicion_inicial;
	}

	assert(r);

	return r;
}

static inline natural *mapear_a_posicion_ordenada(natural *nums,
		natural nums_tam, natural *nums_res, natural nums_res_tam) {
	numero_orden *nums_ord = NULL;

	assert(nums_res_tam >= nums_tam);

	nums_ord = calloc(nums_tam, sizeof(numero_orden));
	assert(nums_ord);

	for (natural i = 0; i < nums_tam; i++) {
		numero_orden *num_ord_act = nums_ord + i;

		num_ord_act->numero = nums[i];
		num_ord_act->posicion_inicial = i;
	}

	qsort(nums_ord, nums_tam, sizeof(numero_orden), compara_numero_orden);

	for (natural i = 0; i < nums_tam; i++) {
		numero_orden *num_ord_act = nums_ord + i;
		nums_res[num_ord_act->posicion_inicial] = i;
	}

	free(nums_ord);
	return nums_res;
}
#endif

#if 1

#define BIT_CH_VALOR_INVALIDO ULLONG_MAX

typedef struct bit_ch {
	natural num_nodos_bit_ch;
	tipo_dato *nodos_bit_ch;
} bit_ch;

static inline void bit_ch_aumenta(bit_ch *bit, tipo_dato nuevo_valor,
		natural idx);

static inline void bit_ch_init(bit_ch *bit, tipo_dato valor_inicial,
		natural num_cacas) {
	tipo_dato *nodos = NULL;

	bit->num_nodos_bit_ch = num_cacas + 2;

	bit->nodos_bit_ch = calloc(bit->num_nodos_bit_ch, sizeof(tipo_dato));
	nodos = bit->nodos_bit_ch;

	nodos[0] = (tipo_dato) BIT_CH_VALOR_INVALIDO;
	for (natural i = 1; i < bit->num_nodos_bit_ch; i++) {
		nodos[i] = 0;
	}

	bit_ch_aumenta(bit, valor_inicial, 1);
}

static inline void bit_ch_fini(bit_ch *bit) {
	free(bit->nodos_bit_ch);
}

static inline void bit_ch_aumenta(bit_ch *bit, tipo_dato nuevo_valor,
		natural idx) {
	tipo_dato *nodos = bit->nodos_bit_ch;
	caca_log_debug("q verga actualizando %u con %d", idx, nuevo_valor);
	for (natural i = idx; i && i <= bit->num_nodos_bit_ch; i += (i & (-i))) {
		caca_log_debug("actualizando caca %u con %d antes %d", i, nuevo_valor,
				nodos[i]);
		nodos[i] += nuevo_valor;
		caca_log_debug("actualizado caca %u aora %d", i, nodos[i]);
	}
}

static inline tipo_dato bit_ch_consulta(bit_ch *bit, natural idx) {
	tipo_dato *nodos = bit->nodos_bit_ch;
	tipo_dato res = 0;
	for (int i = idx; i > 0; i -= (i & (-i))) {
		assert_timeout(i < bit->num_nodos_bit_ch);
		caca_log_debug("consultando caca %u tiene %u", i, nodos[i]);
		res += nodos[i];
	}
	caca_log_debug("regresando %d", res);
	return res;
}

static inline tipo_dato bit_ch_consulta_rango_actualizacion_puntual(bit_ch *bit,
		natural i, natural j) {
	return bit_ch_consulta(bit, j) - bit_ch_consulta(bit, i - 1);
}

static inline tipo_dato bit_ch_consulta_fondo(bit_ch *bit, natural i) {
	return bit_ch_consulta_rango_actualizacion_puntual(bit, i,
			bit->num_nodos_bit_ch - 1);
}

static inline void bit_ch_aumenta_rango(bit_ch *bit, tipo_dato nuevo_valor,
		natural idx_ini, natural idx_fin) {
	caca_log_debug("aumentando de %u a %u con valor %I64d", idx_ini, idx_fin,
			nuevo_valor);

	bit_ch_aumenta(bit, nuevo_valor, idx_ini);
	bit_ch_aumenta(bit, -nuevo_valor, idx_fin + 1);
}

static inline void bit_ch_aumenta_rango_consulta_rango(bit_ch *bit_puto,
		bit_ch *bit_aux, natural idx_ini, natural idx_fin,
		tipo_dato nuevo_valor) {

	caca_log_debug("aumentando de %u a %u con valor %I64d para consulta rango",
			idx_ini, idx_fin, nuevo_valor);

	bit_ch_aumenta_rango(bit_puto, nuevo_valor, idx_ini, idx_fin);
	caca_log_debug(
			"actualizando para consulta rango inicial %d con %I64d (%I64d * %u)",
			idx_ini, nuevo_valor * (idx_ini - 1), nuevo_valor, idx_ini - 1);
	bit_ch_aumenta(bit_aux, nuevo_valor * (idx_ini - 1), idx_ini);
	caca_log_debug(
			"actualizando para consulta rango final %d con %I64d(%I64d,%u)",
			idx_fin + 1, -nuevo_valor * idx_fin, -nuevo_valor, idx_fin);
	bit_ch_aumenta(bit_aux, -nuevo_valor * idx_fin, idx_fin + 1);
}

static inline tipo_dato bit_ch_consulta_rango_actualizado_rango(
		bit_ch *bit_puto, bit_ch *bit_aux, natural idx) {
	tipo_dato resul = 0;
	tipo_dato valor_puto = 0;
	tipo_dato valor_aux = 0;

	valor_puto = bit_ch_consulta(bit_puto, idx);

	caca_log_debug(
			"el valor putual en %u es %I64d, aportara %I64d (%I64d * %u)", idx,
			valor_puto, valor_puto * idx, valor_puto, idx);

	valor_aux = bit_ch_consulta(bit_aux, idx);

	caca_log_debug("el valor aux en %u es %I64d", idx, valor_puto);

	resul = valor_puto * idx - valor_aux;

	caca_log_debug("la suma acumulacaca hasta %u es %I64d", idx, resul);

	return resul;
}

static inline tipo_dato bit_ch_consulta_rango(bit_ch *bit_puto, bit_ch *bit_aux,
		natural idx_ini, natural idx_fin) {
	tipo_dato resul = 0;
	tipo_dato resul_idx_ini = 0;
	tipo_dato resul_idx_fin = 0;

	resul_idx_ini = bit_ch_consulta_rango_actualizado_rango(bit_puto, bit_aux,
			idx_ini - 1);
	caca_log_debug("la suma acumulacaca ini hasta %u es %I64d", idx_ini,
			resul_idx_ini);

	resul_idx_fin = bit_ch_consulta_rango_actualizado_rango(bit_puto, bit_aux,
			idx_fin);
	caca_log_debug("la suma acumulacaca fin hasta %u es %I64d", idx_fin,
			resul_idx_fin);

	resul = resul_idx_fin - resul_idx_ini;

	caca_log_debug("la suma acumulacaca del rango %u-%u es %I64d", idx_ini,
			idx_fin, resul);

	return resul;
}

#endif

static inline natural modifica(bit_ch *bi, bit_ch *bd, natural *a, natural i,
		bool quitar) {
	natural inv = 0;
	bit_ch *bm = NULL;
	int factor = 0;
	inv = bit_ch_consulta_fondo(bi, a[i] + 1) + bit_ch_consulta(bd, a[i] - 1);

	if (quitar) {
		bm = bd;
		factor = -1;
	} else {
		bm = bi;
		factor = 1;
	}
	caca_log_debug("el puto factor %d", factor);

	bit_ch_aumenta(bm, factor, a[i]);
	caca_log_debug("las inv al %s %u son %u", quitar?"quitar":"poner", a[i],
			inv);

	return inv;
}

static inline natural quita(bit_ch *bi, bit_ch *bd, natural *a, natural i) {
	return modifica(bi, bd, a, i, verdadero);
}

static inline natural anade(bit_ch *bi, bit_ch *bd, natural *a, natural i) {
	return modifica(bi, bd, a, i, falso);
}

static inline entero_largo_sin_signo core(natural *nums, natural nums_tam,
		entero_largo_sin_signo k) {
	entero_largo_sin_signo inv = 0;
	bit_ch *bi = caca_comun_calloc_local(bit_ch);
	bit_ch *bd = caca_comun_calloc_local(bit_ch);
	natural j = 0;
	entero_largo_sin_signo r = 0;
	natural *a = NULL;

	a = calloc(nums_tam, sizeof(natural));
	assert_timeout(a);

	mapear_a_posicion_ordenada(nums, nums_tam, a, nums_tam);
	for (natural i = 0; i < nums_tam; i++) {
		a[i]++;
	}
	caca_log_debug("mapeados %s",
			caca_comun_arreglo_a_cadena_natural(a, nums_tam, CACA_COMUN_BUF_STATICO));

	bit_ch_init(bi, 0, nums_tam);
	bit_ch_init(bd, 0, nums_tam);

	for (natural i = 0; i < nums_tam; i++) {
		caca_log_debug("anadiendo %u en pos %u", a[i], i);
		inv += bit_ch_consulta_fondo(bd, a[i]);
		bit_ch_aumenta(bd, 1, a[i]);
	}

	caca_log_debug("inv totales %I64d", inv);

	anade(bi, bd, a, 0);
	for (natural i = 1; i < nums_tam; i++) {
		while (j < nums_tam && (j < i || inv > k)) {
			inv -= quita(bi, bd, a, j);
			j++;
			caca_log_debug("kitando %u en pos %u inv %I64d", a[j-1], j-1, inv);
		}

		r += nums_tam - j;

		caca_log_debug("en %u %u inv %I64d r %I64d", i, j, inv, r)

		inv += anade(bi, bd, a, i);
	}

	bit_ch_fini(bi);
	bit_ch_fini(bd);

	return r;
}

#define MAX_CACA ((int)1E5)
natural a[MAX_CACA] = { 0 };

int main() {
	natural n = 0;
	entero_largo_sin_signo k = 0;

	scanf("%u %u\n", &n, &k);
	assert_timeout(n<=MAX_CACA);
	assert_timeout(k < ((entero_largo_sin_signo )(1E18)));

	for (natural i = 0; i < n; i++) {
		scanf("%u", &a[i]);
	}

	printf("%I64d\n", core(a, n, k));
	return EXIT_SUCCESS;
}


//spnauti-rusT {{{
use std::io::*; use std::str::{self,*}; use std::fmt::Debug;
#[allow(unused_imports)] use std::cmp::Ordering::{self,*};
#[allow(unused_imports)] use std::ops::{self,*};
#[allow(unused_imports)] use std::iter::{self,*};
#[allow(unused_imports)] use std::collections::*;
#[allow(unused_imports)] use std::cell::*;
#[allow(unused_macros)] macro_rules! m {
	($c:tt,$x:expr,$y:expr) => {{
		let b=$y; let a=&mut$x; if b$c*a {*a=b; true} else {false}
	}};
}
#[allow(unused_macros)] macro_rules! l {
	($($v:ident),+ =$e:expr) => {$(let$v=$e;)+};
	($($v:ident),+:$t:ty=$e:expr) => {$(let$v:$t=$e;)+};
	(mut $($v:ident),+ =$e:expr) => {$(let mut$v=$e;)+};
	(mut $($v:ident),+:$t:ty=$e:expr) => {$(let mut$v:$t=$e;)+};
}
#[allow(unused_macros)] macro_rules! vec_dim {
	([$d:expr]$($s:tt)+) => {vec![vec_dim!($($s)+);$d]}; (=$e:expr) => {$e};
}
#[allow(unused_macros)] macro_rules! rep { {[$c:expr]$($s:tt)+} => {for _ in 0..$c {$($s)+}} }
#[allow(dead_code)] fn reader() -> WordReaderC { WordReaderC::new() }
#[allow(dead_code)] fn writer() -> BufWriter<Stdout> { BufWriter::new(stdout()) }
struct WordReaderC {buf: Vec<u8>, pos: usize, q: std::io::StdinLock<'static>}//'
#[allow(dead_code)] impl WordReaderC {
	fn new() -> Self {
		let r = unsafe {&*Box::into_raw(Box::new(stdin()))};
		Self { q: r.lock(), buf: Vec::new(), pos: 0 }
	}
	fn next_line(&mut self) -> bool {
		self.buf.clear(); self.pos = 0;
		self.q.read_until(b'\n', &mut self.buf).unwrap_or(0) > 0
	}
	fn is_ws(c: u8) -> bool {
		c == b' ' || c == b'\r' || c == b'\n' || c == b'\t'
	}
	fn byte(&mut self) -> Option<u8> {
		if self.pos == self.buf.len() { if !self.next_line() { return None; } }
		self.pos += 1; Some(self.buf[self.pos - 1])
	}
	fn vb(&mut self) -> Vec<u8> {
		let mut s = Vec::with_capacity(8);
		let mut f = false;
		loop {
			if let Some(c) = self.byte() {
				if !Self::is_ws(c) {
					s.push(c);
					f = true;
				} else if f { break; }
			} else { break; }
		}
		s
	}
	fn s(&mut self) -> String { String::from_utf8(self.vb()).expect("invalid utf8") }
	fn i(&mut self) ->    i32 { self.p() }
	fn l(&mut self) ->    i64 { self.p() }
	fn u(&mut self) ->  usize { self.p() }
	fn f(&mut self) ->    f64 { self.p() }
	fn vi(&mut self, n: usize) -> Vec<i32> { self.vp(n) }
	fn vl(&mut self, n: usize) -> Vec<i64> { self.vp(n) }
	fn vu(&mut self, n: usize) -> Vec<usize> { self.vp(n) }
	fn ii(&mut self, n: usize) -> impl Iterator<Item=i32> { self.ip(n).into_iter() }
	fn iu(&mut self, n: usize) -> impl Iterator<Item=usize> { self.ip(n).into_iter() }
	fn p<T: FromStr>(&mut self) -> T where T::Err: Debug {
		let w = self.vb(); str::from_utf8(w.as_ref()).unwrap().parse::<T>().unwrap()
	}
	fn vp<T: FromStr>(&mut self, n: usize) -> Vec<T> where T::Err: Debug {
		(0..n).map(|_|self.p()).collect()
	}
	fn ip<T: FromStr>(&mut self, n: usize) -> impl Iterator<Item=T> where T::Err: Debug {
		self.vp(n).into_iter()
	}
}
//------------------- End rusT }}}

// Fenwick Tree {{{
mod fenwick {
	type V = i64;
	pub struct Tree {
		n: usize,
		pub arr: Box<[V]>
	}
	impl Tree {
		pub fn new(n: usize) -> Self {
			let arr = vec![0; n + 1].into_boxed_slice();
			Self { n, arr }
		}
		pub fn add(&mut self, p: usize, v: V) {
			let mut p = p as i32;
			let n = self.n as i32;
			while p <= n {
				self.arr[p as usize] += v;
				p += p & -p;
			}
		}
		pub fn sum(&self, p: usize) -> V {
			let mut p = p as i32;
			let mut res = 0;
			while p > 0 {
				res += self.arr[p as usize];
				p -= p & -p;
			}
			res
		}
	}
}//}}}
// Coordinate compression {{{
fn compress<T: Ord>(a: &[T], start_from: usize) -> (usize, Vec<usize>) {
	let n = a.len();
	let mut t = Vec::with_capacity(n);
	for i in 0..n {
		t.push(i);
	}
	t.sort_by(|x,y| a[*x].cmp(&a[*y]));
	let mut b = vec![0; n];
	let mut v = start_from;
	for i in 0..n {
		if i > 0 && a[t[i-1]] < a[t[i]] {
			v += 1;
		}
		b[t[i]] = v;
	}
	(v, b)
}//}}}

fn main() {
	let mut rin = reader();
	let mut rout = writer();

	let n = rin.u();
	let k = rin.l();
	let a = rin.vi(n);
	let (m,a) = compress(&a,1);
	l!(mut fl,fr = fenwick::Tree::new(m));
	let mut inv = 0_i64;
	for i in (1..n).rev() {
		inv += fr.sum(a[i]-1);
		fr.add(a[i], 1);
	}
	let mut sol = 0_i64;
	let mut j = 1;
	for i in 0..n-1 {
		inv += fl.sum(m) - fl.sum(a[i]) + fr.sum(a[i]-1);
		fl.add(a[i], 1);
		while j < n && (i == j || inv > k) {
			fr.add(a[j], -1);
			inv -= fl.sum(m) - fl.sum(a[j]) + fr.sum(a[j]-1);
			j += 1;
		}
		sol += (n - j) as i64;
	}
	writeln!(rout, "{}", sol).ok();
}


# 220E
import sys

class BIT():
    def __init__(self, n):
        self.n = n
        self.tree = [0] * n

    def _F(self, i):
        return i & (i + 1)

    def _get_sum(self, r):
        '''
        sum on interval [0, r)
        '''
        result = 0
        while r > 0:
            result += self.tree[r-1]
            r = self._F(r-1)
        return result

    def get_sum(self, l, r):
        '''
        sum on interval [l, r)
        '''
        return self._get_sum(r) - self._get_sum(l)

    def _H(self, i):
        return i | (i + 1)

    def add(self, i, value=1):
        while i < self.n:
            self.tree[i] += value
            i = self._H(i)

reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__

n, k = map(int, input().split())
a = list(map(int, input().split()))
pos = {val:i for i, val in enumerate(a)}
for i, val in enumerate(sorted(a)):
    a[pos[val]] = i

left = BIT(n)
right = BIT(n)
total_inv = 0

left.add(a[0])
for t in range(1, n):
    i = a[t]
    total_inv += right.get_sum(i, n)
    right.add(i)
    if i < a[0]:
        total_inv += 1

# print(total_inv, k)
if total_inv <= k:
    print((n*(n-1))>>1)
    sys.exit()

l = 0
r = 1
while r < n and total_inv > k:
    total_inv -= left.get_sum(a[r], n) + right.get_sum(0, a[r])
    right.add(a[r], -1)
    r += 1

pairs = 0
while r < n:
    while True:
        add = left.get_sum(a[l+1], n) + right.get_sum(0, a[l+1])
        if total_inv + add > k:
            pairs += l + 1
            break
        else:
            l += 1
            total_inv += add
            left.add(a[l])
    total_inv -= left.get_sum(a[r], n) + right.get_sum(0, a[r])
    right.add(a[r], -1)
    r += 1
print(pairs)


# 220E
import sys
from collections import defaultdict

class BIT():
    def __init__(self, n):
        self.n = n
        self.tree = [0] * n

    def _F(self, i):
        return i & (i + 1)

    def _get_sum(self, r):
        '''
        sum on interval [0, r)
        '''
        result = 0
        while r > 0:
            result += self.tree[r-1]
            r = self._F(r-1)
        return result

    def get_sum(self, l, r):
        '''
        sum on interval [l, r)
        '''
        return self._get_sum(r) - self._get_sum(l)

    def _H(self, i):
        return i | (i + 1)

    def add(self, i, value=1):
        while i < self.n:
            self.tree[i] += value
            i = self._H(i)

reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__

n, k = map(int, input().split())
a = list(map(int, input().split()))

pos = defaultdict(list)
for i, val in enumerate(a):
    pos[val].append(i)

i = 0
prev = -1
for val in sorted(a):
    if prev == val: continue
    for j in pos[val]:
        a[j] = i
    i += 1
    prev = val

left = BIT(n)
right = BIT(n)
total_inv = 0

left.add(a[0])
for t in range(1, n):
    i = a[t]
    total_inv += right.get_sum(i+1, n)
    right.add(i)
    if i < a[0]:
        total_inv += 1

if total_inv <= k:
    print((n*(n-1))>>1)
    sys.exit()

l = 0
r = 1
while r < n and total_inv > k:
    total_inv -= left.get_sum(a[r]+1, n) + right.get_sum(0, a[r])
    right.add(a[r], -1)
    r += 1

pairs = 0
while r < n:
    while True:
        add = left.get_sum(a[l+1]+1, n) + right.get_sum(0, a[l+1])
        if total_inv + add > k:
            pairs += l + 1
            break
        else:
            l += 1
            total_inv += add
            left.add(a[l])
    total_inv -= left.get_sum(a[r]+1, n) + right.get_sum(0, a[r])
    right.add(a[r], -1)
    r += 1
print(pairs)


'''
Created on 19/07/2018

@author: ernesto
'''

# XXX: http://codeforces.com/problemset/problem/220/E
#  XXX: https://practice.geeksforgeeks.org/problems/magic-triplets/0

# XXX: https://gist.github.com/robert-king/5660418
class RangeBit:

    def __init__(self, n):
        sz = 1
        while n >= sz:
            sz *= 2
        self.size = sz
        self.dataAdd = [0] * sz
        self.dataMul = [0] * sz

    def sum(self, i):
        r = 0
        if i > 0:
            add = 0
            mul = 0
            start = i
            while i > 0:
                add += self.dataAdd[i]
                mul += self.dataMul[i]
                i -= i & -i
            r = mul * start + add
        return r

    def add(self, left, right, by):
        assert 0 < left <= right
        self._add(left, by, -by * (left - 1))
        self._add(right, -by, by * right)

    def _add(self, i, mul, add):
        assert i > 0
        while i < self.size:
            self.dataAdd[i] += add
            self.dataMul[i] += mul
            i += i & -i

    def sum_range(self, i, j):
#        print("j {} s {}".format(j, self.sum(j)))
#        print("i {} s {}".format(i, self.sum(i)))
        return self.sum(j) - self.sum(i - 1)

    def sum_back(self, i):
        return self.sum_range(i, self.size - 1)

    def add_point(self, i, by):
        self.add(i, i, by)

class numero():

    def __init__(self, valor, posicion_inicial):
        self.valor = valor
        self.posicion_inicial = posicion_inicial
        self.posicion_final = -1;

    def __lt__(self, other):
        if self.valor == other.valor:
            r = self.posicion_inicial < other.posicion_inicial
        else:
            r = self.valor < other.valor
        return r

    def __repr__(self):
        return "{}:{}:{}".format(self.valor, self.posicion_inicial, self.posicion_final)

def swap(a, i, j):
    a[i], a[j] = a[j], a[i]

def crea_arreglo_enriquecido(nums):
    numse = list(sorted(map(lambda t:numero(t[1], t[0]), enumerate(nums))))
#    print("numse {}".format(numse))
    for i, n in enumerate(numse):
        n.posicion_final = i
    return list(sorted(numse, key=lambda n:n.posicion_inicial))

def fuerza_bruta(a):
    a_len = len(a)
    r = 0
    for i in range(a_len):
        for j in range(i):
            if a[i] < a[j]:
                r += 1
    return r

def quita(bi, bd, a, i):
    return modifica(bi, bd, a, i, False)

def anade(bi, bd, a, i):
    return modifica(bi, bd, a, i, True)

def modifica(bi, bd, a, i, anade):
    if anade:
        bc = bi
        fac = 1
    else:
        bc = bd
        fac = -1

    inv = bi.sum_back(a[i] + 1) + bd.sum(a[i] - 1)
#    print("num {} parte de i {} de d {} fact {}".format(a[i], bi.sum(a[i] + 1), bd.sum(a[i] - 1), fac))
    bc.add_point(a[i], fac)

    return inv

def core(nums, nmi):
    numse = crea_arreglo_enriquecido(nums)
#    print("numse {}".format(numse))
    a = list(map(lambda x:x.posicion_final + 1, numse))
#    print("a {}".format(list(map(lambda x:x - 1, a))))
    i = 0
    j = 0
    ni = 0
    r = 0
    a_len = len(a)

    bitch_izq = RangeBit(a_len + 2)
    bitch_der = RangeBit(a_len + 2)

    nif = 0
    for i, x in enumerate(a):
        nif += bitch_der.sum_range(x + 1, a_len)
        bitch_der.add(x, x, 1)
#        print("en x {} ({}) nif {}".format(x, numse[i].valor , nif))

    j = 0
    ni = nif
#    print("ni ini {}".format(ni))
    ni += anade(bitch_izq, bitch_der, a, 0)
    for i in range(1, a_len):
        while j < a_len and (j < i or ni > nmi):
            ni -= quita(bitch_izq, bitch_der, a, j)
#            print("en j {} se kito {} {}".format(j, nums[j], ni))
            j += 1
        r += a_len - j
#        print("en i {} j {} anadido {} inv {}".format(i, j, a_len - j, ni))
        ni += anade(bitch_izq, bitch_der, a, i)
#        print("en i {} se puso {}".format(i, ni))

#    print("r f aora {}".format(r))

    return r

_, k = [int(x) for x in input().strip().split(" ")]
nums = [int(x) for x in input().strip().split(" ")]
# nums = [6, 8, 6, 7, 2, 4, 2, 1, 7, 6, 2, 1, 2, 3, 2, 5, 3, 7, 1, 7, 7]
# nums = [1, 3, 2, 1, 7]
# nums = [1, 3, 2]
# k = 0

print(core(nums, k))


'''
Created on 19/07/2018

@author: ernesto
'''

# XXX: http://codeforces.com/problemset/problem/220/E
#  XXX: https://practice.geeksforgeeks.org/problems/magic-triplets/0

# XXX: https://gist.github.com/robert-king/5660418
class RangeBit:

    def __init__(self, n):
        sz = 1
        while n >= sz:
            sz *= 2
        self.size = sz
        self.dataAdd = [0] * sz
        self.dataMul = [0] * sz

    def sum(self, i):
        r = 0
        if i > 0:
            add = 0
            mul = 0
            start = i
            while i > 0:
                add += self.dataAdd[i]
                mul += self.dataMul[i]
                i -= i & -i
            r = mul * start + add
        return r

    def add(self, left, right, by):
        assert 0 < left <= right
        self._add(left, by, -by * (left - 1))
        self._add(right, -by, by * right)

    def _add(self, i, mul, add):
        assert i > 0
        while i < self.size:
            self.dataAdd[i] += add
            self.dataMul[i] += mul
            i += i & -i

    def sum_range(self, i, j):
#        print("j {} s {}".format(j, self.sum(j)))
#        print("i {} s {}".format(i, self.sum(i)))
        return self.sum(j) - self.sum(i - 1)

    def sum_back(self, i):
        return self.sum_range(i, self.size - 1)

    def add_point(self, i, by):
        self.add(i, i, by)

class numero():

    def __init__(self, valor, posicion_inicial):
        self.valor = valor
        self.posicion_inicial = posicion_inicial
        self.posicion_final = -1;

    def __lt__(self, other):
        if self.valor == other.valor:
            r = self.posicion_inicial < other.posicion_inicial
        else:
            r = self.valor < other.valor
        return r

    def __repr__(self):
        return "{}:{}:{}".format(self.valor, self.posicion_inicial, self.posicion_final)

def swap(a, i, j):
    a[i], a[j] = a[j], a[i]

def crea_arreglo_enriquecido(nums):
    numse = list(sorted(map(lambda t:numero(t[1], t[0]), enumerate(nums))))
    r = [0] * len(nums)
#    print("numse {}".format(numse))
    for i, n in enumerate(numse):
        r[n.posicion_inicial] = i + 1
    return r

def fuerza_bruta(a):
    a_len = len(a)
    r = 0
    for i in range(a_len):
        for j in range(i):
            if a[i] < a[j]:
                r += 1
    return r

def quita(bi, bd, a, i):
    return modifica(bi, bd, a, i, False)

def anade(bi, bd, a, i):
    return modifica(bi, bd, a, i, True)

def modifica(bi, bd, a, i, anade):
    if anade:
        bc = bi
        fac = 1
    else:
        bc = bd
        fac = -1

    inv = bi.sum_back(a[i] + 1) + bd.sum(a[i] - 1)
#    print("num {} parte de i {} de d {} fact {}".format(a[i], bi.sum(a[i] + 1), bd.sum(a[i] - 1), fac))
    bc.add_point(a[i], fac)

    return inv

def core(nums, nmi):
    numse = crea_arreglo_enriquecido(nums)
#    print("numse {}".format(numse))
    a = numse
#    print("a {}".format(list(map(lambda x:x - 1, a))))
    i = 0
    j = 0
    ni = 0
    r = 0
    a_len = len(a)

    bitch_izq = RangeBit(a_len + 2)
    bitch_der = RangeBit(a_len + 2)

    nif = 0
    for i, x in enumerate(a):
        nif += bitch_der.sum_range(x + 1, a_len)
        bitch_der.add(x, x, 1)
#        print("en x {} ({}) nif {}".format(x, numse[i].valor , nif))

    j = 0
    ni = nif
#    print("ni ini {}".format(ni))
    ni += anade(bitch_izq, bitch_der, a, 0)
    for i in range(1, a_len):
        while j < a_len and (j < i or ni > nmi):
            ni -= quita(bitch_izq, bitch_der, a, j)
#            print("en j {} se kito {} {}".format(j, nums[j], ni))
            j += 1
        r += a_len - j
#        print("en i {} j {} anadido {} inv {}".format(i, j, a_len - j, ni))
        ni += anade(bitch_izq, bitch_der, a, i)
#        print("en i {} se puso {}".format(i, ni))

#    print("r f aora {}".format(r))

    return r

_, k = [int(x) for x in input().strip().split(" ")]
nums = [int(x) for x in input().strip().split(" ")]
# nums = [6, 8, 6, 7, 2, 4, 2, 1, 7, 6, 2, 1, 2, 3, 2, 5, 3, 7, 1, 7, 7]
# nums = [1, 3, 2, 1, 7]
# nums = [1, 3, 2]
# k = 0

print(core(nums, k))


import java.util.*

fun main() {
    var tokenizer = StringTokenizer(readLine()!!)
    val n = tokenizer.nextToken().toInt()
    val k = tokenizer.nextToken().toLong()
    tokenizer = StringTokenizer(readLine()!!)
    val array = Array(n) { tokenizer.nextToken().toInt() }
    val xs = TreeSet<Int>()
    xs.addAll(array)
    var ix = 0
    val xix = mutableMapOf<Int, Int>()
    for (x in xs) {
        ix++
        xix[x] = ix
    }
    val leftBIT = BinaryIndexTree(1, ix)
    val rightBIT = BinaryIndexTree(1, ix)
    var answer = 0L
    var curr = 0L
    for (j in 0 until n) {
        val jx = xix[array[j]]!!
        curr += rightBIT.query(jx + 1, ix)
        rightBIT.update(jx, 1L)
    }
    var r = 0
    for (l in 0 until n) {
        var jx = xix[array[l]]!!
        if (r == l) {
            rightBIT.update(jx, -1L)
            r++
        } else {
            curr += leftBIT.query(jx + 1, ix)
            curr += rightBIT.query(1, jx - 1)
        }
        leftBIT.update(jx, 1L)
        while (r < n && curr > k) {
            jx = xix[array[r]]!!
            curr -= leftBIT.query(jx + 1, ix)
            curr -= rightBIT.query(1, jx - 1)
            rightBIT.update(jx, -1L)
            r++
        }
        answer += (n - r).toLong()
    }
    println(answer)
}

class BinaryIndexTree(treeFrom: Int, treeTo: Int) {
    val `val`: LongArray
    val treeFrom: Int
    fun update(index: Int, delta: Long) {
        var i = index + 1 - treeFrom
        while (i < `val`.size) {
            `val`[i] += delta
            i += i and -i
        }
    }

    fun query(to: Int): Long {
        var res: Long = 0
        var i = to + 1 - treeFrom
        while (i > 0) {
            res += `val`[i]
            i -= i and -i
        }
        return res
    }

    fun query(from: Int, to: Int): Long {
        return if (to < from) {
            0L
        } else query(to) - query(from - 1)
    }

    init {
        `val` = LongArray(treeTo - treeFrom + 2)
        this.treeFrom = treeFrom
    }
}


#include <iostream>
#include <string>
#include <cstdio>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <sstream>
#include <algorithm>
using namespace std;
#define rep(_m,s,e) for(int _m=s;_m<e;_m++)
typedef long long ll;
int  toInt(string s)   {int r=0; istringstream sin(s); sin>>r; return r;}
ll   toInt64(string s) {ll r=0; istringstream sin(s); sin>>r; return r;}
double  toDouble(string s){double r=0; istringstream sin(s); sin>>r; return r;}
string toString(ll n) {string s,s1; while (n / 10 > 0){ s += (char)((n%10) + 48); n/=10;} s += (char)((n%10) + 48); n/=10; s1 = s; rep(i,0,s.length()) s1[(s.length()-1)-i] = s[i]; return s1;}
bool isUpperCase(char c){return c >= 'A' && c <= 'Z';}
bool isLowerCase(char c){return c >= 'a' && c <= 'z';}
bool isLetter(char c)   {return c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z';}
bool isDigit(char c)    {return c >= '0' && c <= '9';}
char toLowerCase(char c){return (isUpperCase(c))?(c + 32) : c;}
char toUpperCase(char c){return (isLowerCase(c))?(c - 32) : c;}
ll gcd(ll a, ll b) {if(!a) return b; return gcd(b%a, a);}

int x[100001];
int n;

const int MAXN = 100001;

struct fenwick{
	int fen[100001];
	int get(int andis)
	{

		if (andis == 0)
			return 0;
		return fen[andis] + get(andis - (andis & (-andis)));
	}
	void add(int x, int val)
	{
		for (;x <= MAXN; x += x & -x)
			fen[x] += val;
	}
	void clear()
	{
		fill(fen, fen+MAXN, 0);
	}
};

int L[100001], R[100001];
fenwick F;
fenwick fL, fR;

map<int, int> MAP;

int y[MAXN];

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	ll k;
	cin >> n >> k;
	rep(i,0,n)
		cin >> x[i], y[i] = x[i];
	sort(y, y + n);
	for (int i = 1; i <= n; i++)
		if (MAP[y[i-1]] == 0) MAP[y[i-1]] = i;
	L[0] = 0;
	F.add(MAP[x[0]], 1);
	for (int i = 1; i < n; i++)
	{
		L[i] = L[i-1];
		F.add(MAP[x[i]], 1);
		L[i] += (i+1)-F.get(MAP[x[i]]);
	}
	F.clear();
	R[n-1] = 0;
	F.add(MAP[x[n-1]], 1);
	for (int i = n-2; i >= 0; i--)
	{
		R[i] = R[i+1];
		F.add(MAP[x[i]], 1);
		R[i] += F.get(MAP[x[i]])-1;
	}
	ll cnt = 0;
	int l = 0, r = 1;
	for (int i = 1; i < n; i++)
		fR.add(MAP[x[i]], 1);
	fL.add(MAP[x[0]], 1);
	ll ans = 0;
	fR.add(MAP[x[0]], 1);
	cnt += fR.get(MAP[x[0]])-1;
	cnt += L[0] + R[1];
	fR.add(MAP[x[0]], -1);
	while (l < n && r < n)
	{
		int tmpR = r, tmpL = l;
		if (cnt <= k)
		{
			ans += n - r;
			l++;
			fL.add(MAP[x[l]], 1);

			fR.add(MAP[x[l]], 1);
			cnt += fR.get(MAP[x[l]])-1;
			fR.add(MAP[x[l]], -1);

			if (l == r)
			{
				fR.add(MAP[x[r]], -1);
				fL.add(MAP[x[r]], 1);
				cnt -= (l+2) - fL.get(MAP[x[r]]);
				fL.add(MAP[x[r]], -1);
				r++;
			}
		}
		else {
			fR.add(MAP[x[r]], -1);
			fL.add(MAP[x[r]], 1);
			cnt -= (l+2) - fL.get(MAP[x[r]]);
			fL.add(MAP[x[r]], -1);
			r++;
		}
		cnt -= L[tmpL] + R[tmpR];
		cnt += L[l] + R[r];
	}
	cout << ans << endl;
}


#include <iostream>
#include <string>
#include <cstdio>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <sstream>
#include <algorithm>
using namespace std;
#define rep(_m,s,e) for(int _m=s;_m<e;_m++)
typedef long long ll;
int  toInt(string s)   {int r=0; istringstream sin(s); sin>>r; return r;}
ll   toInt64(string s) {ll r=0; istringstream sin(s); sin>>r; return r;}
double  toDouble(string s){double r=0; istringstream sin(s); sin>>r; return r;}
string toString(ll n) {string s,s1; while (n / 10 > 0){ s += (char)((n%10) + 48); n/=10;} s += (char)((n%10) + 48); n/=10; s1 = s; rep(i,0,s.length()) s1[(s.length()-1)-i] = s[i]; return s1;}
bool isUpperCase(char c){return c >= 'A' && c <= 'Z';}
bool isLowerCase(char c){return c >= 'a' && c <= 'z';}
bool isLetter(char c)   {return c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z';}
bool isDigit(char c)    {return c >= '0' && c <= '9';}
char toLowerCase(char c){return (isUpperCase(c))?(c + 32) : c;}
char toUpperCase(char c){return (isLowerCase(c))?(c - 32) : c;}
ll gcd(ll a, ll b) {if(!a) return b; return gcd(b%a, a);}

int x[100001];
int n;

const int MAXN = 100001;

struct fenwick{
	ll fen[100001];
	int get(int andis)
	{

		if (andis == 0)
			return 0;
		return fen[andis] + get(andis - (andis & (-andis)));
	}
	void add(int x, int val)
	{
		for (;x <= MAXN; x += x & -x)
			fen[x] += val;
	}
	void clear()
	{
		fill(fen, fen+MAXN, 0);
	}
};

ll L[100001], R[100001];
fenwick F;
fenwick fL, fR;

map<int, int> MAP;

int y[MAXN];

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	ll k;
	cin >> n >> k;
	rep(i,0,n)
		cin >> x[i], y[i] = x[i];
	sort(y, y + n);
	for (int i = 1; i <= n; i++)
		if (MAP[y[i-1]] == 0) MAP[y[i-1]] = i;
	L[0] = 0;
	F.add(MAP[x[0]], 1);
	for (int i = 1; i < n; i++)
	{
		L[i] = L[i-1];
		F.add(MAP[x[i]], 1);
		L[i] += (i+1)-F.get(MAP[x[i]]);
	}
	F.clear();
	R[n-1] = 0;
	F.add(MAP[x[n-1]], 1);
	for (int i = n-2; i >= 0; i--)
	{
		R[i] = R[i+1];
		F.add(MAP[x[i]], 1);
		R[i] += F.get(MAP[x[i]]-1);
	}
	ll cnt = 0;
	int l = 0, r = 1;
	for (int i = 1; i < n; i++)
		fR.add(MAP[x[i]], 1);
	fL.add(MAP[x[0]], 1);
	ll ans = 0;
	fR.add(MAP[x[0]], 1);
	cnt += fR.get(MAP[x[0]]-1);
	cnt += L[0] + R[1];
	fR.add(MAP[x[0]], -1);
	while (l < n && r < n)
	{
		int tmpR = r, tmpL = l;
		if (cnt <= k)
		{
			ans += n - r;
			l++;
			if (l == r)
			{
				fR.add(MAP[x[r]], -1);
				fL.add(MAP[x[r]], 1);
				cnt -= (l+2) - fL.get(MAP[x[r]]);
				fL.add(MAP[x[r]], -1);
				r++;
			}
			fL.add(MAP[x[l]], 1);

			fR.add(MAP[x[l]], 1);
			cnt += fR.get(MAP[x[l]]-1);
			fR.add(MAP[x[l]], -1);

		}
		else {
			fR.add(MAP[x[r]], -1);
			fL.add(MAP[x[r]], 1);
			cnt -= (l+2) - fL.get(MAP[x[r]]);
			fL.add(MAP[x[r]], -1);
			r++;
		}
		cnt -= L[tmpL] + R[tmpR];
		cnt += L[l] + R[r];
	}
	cout << ans << endl;
}


#include <iostream>
#include <string>
#include <cstdio>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <sstream>
#include <algorithm>
using namespace std;
#define rep(_m,s,e) for(int _m=s;_m<e;_m++)
typedef long long ll;
int  toInt(string s)   {int r=0; istringstream sin(s); sin>>r; return r;}
ll   toInt64(string s) {ll r=0; istringstream sin(s); sin>>r; return r;}
double  toDouble(string s){double r=0; istringstream sin(s); sin>>r; return r;}
string toString(ll n) {string s,s1; while (n / 10 > 0){ s += (char)((n%10) + 48); n/=10;} s += (char)((n%10) + 48); n/=10; s1 = s; rep(i,0,s.length()) s1[(s.length()-1)-i] = s[i]; return s1;}
bool isUpperCase(char c){return c >= 'A' && c <= 'Z';}
bool isLowerCase(char c){return c >= 'a' && c <= 'z';}
bool isLetter(char c)   {return c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z';}
bool isDigit(char c)    {return c >= '0' && c <= '9';}
char toLowerCase(char c){return (isUpperCase(c))?(c + 32) : c;}
char toUpperCase(char c){return (isLowerCase(c))?(c - 32) : c;}
ll gcd(ll a, ll b) {if(!a) return b; return gcd(b%a, a);}

int x[100001];
int n;

const int MAXN = 100001;

struct fenwick{
	int fen[100001];
	int get(int andis)
	{

		if (andis == 0)
			return 0;
		return fen[andis] + get(andis - (andis & (-andis)));
	}
	void add(int x, int val)
	{
		for (;x <= MAXN; x += x & -x)
			fen[x] += val;
	}
	void clear()
	{
		fill(fen, fen+MAXN, 0);
	}
};

int L[100001], R[100001];
fenwick F;
fenwick fL, fR;

map<int, int> MAP;

int y[MAXN];

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	ll k;
	cin >> n >> k;
	rep(i,0,n)
		cin >> x[i], y[i] = x[i];
	sort(y, y + n);
	for (int i = 1; i <= n; i++)
		if (MAP[y[i-1]] == 0) MAP[y[i-1]] = i;
	L[0] = 0;
	F.add(MAP[x[0]], 1);
	for (int i = 1; i < n; i++)
	{
		L[i] = L[i-1];
		F.add(MAP[x[i]], 1);
		L[i] += (i+1)-F.get(MAP[x[i]]);
	}
	F.clear();
	R[n-1] = 0;
	F.add(MAP[x[n-1]], 1);
	for (int i = n-2; i >= 0; i--)
	{
		R[i] = R[i+1];
		F.add(MAP[x[i]], 1);
		R[i] += F.get(MAP[x[i]]-1);
	}
	ll cnt = 0;
	int l = 0, r = 1;
	for (int i = 1; i < n; i++)
		fR.add(MAP[x[i]], 1);
	fL.add(MAP[x[0]], 1);
	ll ans = 0;
	fR.add(MAP[x[0]], 1);
	cnt += fR.get(MAP[x[0]]-1);
	cnt += L[0] + R[1];
	fR.add(MAP[x[0]], -1);
	while (l < n && r < n)
	{
		int tmpR = r, tmpL = l;
		if (cnt <= k)
		{
			ans += n - r;
			l++;
			if (l == r)
			{
				fR.add(MAP[x[r]], -1);
				fL.add(MAP[x[r]], 1);
				cnt -= (l+2) - fL.get(MAP[x[r]]);
				fL.add(MAP[x[r]], -1);
				r++;
			}
			fL.add(MAP[x[l]], 1);

			fR.add(MAP[x[l]], 1);
			cnt += fR.get(MAP[x[l]]-1);
			fR.add(MAP[x[l]], -1);

		}
		else {
			fR.add(MAP[x[r]], -1);
			fL.add(MAP[x[r]], 1);
			cnt -= (l+2) - fL.get(MAP[x[r]]);
			fL.add(MAP[x[r]], -1);
			r++;
		}
		cnt -= L[tmpL] + R[tmpR];
		cnt += L[l] + R[r];
	}
	cout << ans << endl;
}


#include <iostream>
#include <string>
#include <cstdio>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <sstream>
#include <algorithm>
using namespace std;
#define rep(_m,s,e) for(int _m=s;_m<e;_m++)
typedef long long ll;
int  toInt(string s)   {int r=0; istringstream sin(s); sin>>r; return r;}
ll   toInt64(string s) {ll r=0; istringstream sin(s); sin>>r; return r;}
double  toDouble(string s){double r=0; istringstream sin(s); sin>>r; return r;}
string toString(ll n) {string s,s1; while (n / 10 > 0){ s += (char)((n%10) + 48); n/=10;} s += (char)((n%10) + 48); n/=10; s1 = s; rep(i,0,s.length()) s1[(s.length()-1)-i] = s[i]; return s1;}
bool isUpperCase(char c){return c >= 'A' && c <= 'Z';}
bool isLowerCase(char c){return c >= 'a' && c <= 'z';}
bool isLetter(char c)   {return c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z';}
bool isDigit(char c)    {return c >= '0' && c <= '9';}
char toLowerCase(char c){return (isUpperCase(c))?(c + 32) : c;}
char toUpperCase(char c){return (isLowerCase(c))?(c - 32) : c;}
ll gcd(ll a, ll b) {if(!a) return b; return gcd(b%a, a);}

int x[100001];
int n;

const int MAXN = 100001;

struct fenwick{
	int fen[100001];
	int get(int andis)
	{

		if (andis == 0)
			return 0;
		return fen[andis] + get(andis - (andis & (-andis)));
	}
	void add(int x, int val)
	{
		for (;x <= MAXN; x += x & -x)
			fen[x] += val;
	}
	void clear()
	{
		fill(fen, fen+MAXN, 0);
	}
};

int L[100001], R[100001];
fenwick F;
fenwick fL, fR;

map<int, int> MAP;

int y[MAXN];

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	ll k;
	cin >> n >> k;
	rep(i,0,n)
		cin >> x[i], y[i] = x[i];
	sort(y, y + n);
	for (int i = 1; i <= n; i++)
		if (MAP[x[i-1]] == 0) MAP[x[i-1]] = i;
	L[0] = 0;
	F.add(MAP[x[0]], 1);
	for (int i = 1; i < n; i++)
	{
		L[i] = L[i-1];
		F.add(MAP[x[i]], 1);
		L[i] += (i+1)-F.get(MAP[x[i]]);
	}
	F.clear();
	R[n-1] = 0;
	F.add(MAP[x[n-1]], 1);
	for (int i = n-2; i >= 0; i--)
	{
		R[i] = R[i+1];
		F.add(MAP[x[i]], 1);
		R[i] += F.get(MAP[x[i]])-1;
	}
	ll cnt = 0;
	int l = 0, r = 1;
	for (int i = 1; i < n; i++)
		fR.add(MAP[x[i]], 1);
	fL.add(MAP[x[0]], 1);
	ll ans = 0;
	fR.add(MAP[x[0]], 1);
	cnt += fR.get(MAP[x[0]])-1;
	cnt += L[0] + R[1];
	fR.add(MAP[x[0]], -1);
	while (l < n && r < n)
	{
		int tmpR = r, tmpL = l;
		if (cnt <= k)
		{
			ans += n - r;
			l++;
			fL.add(MAP[x[l]], 1);

			fR.add(MAP[x[l]], 1);
			cnt += fR.get(MAP[x[l]])-1;
			fR.add(MAP[x[l]], -1);

			if (l == r)
			{
				fR.add(MAP[x[r]], -1);
				fL.add(MAP[x[r]], 1);
				cnt -= (l+2) - fL.get(MAP[x[r]]);
				fL.add(MAP[x[r]], -1);
				r++;
			}
		}
		else {
			fR.add(MAP[x[r]], -1);
			fL.add(MAP[x[r]], 1);
			cnt -= (l+2) - fL.get(MAP[x[r]]);
			fL.add(MAP[x[r]], -1);
			r++;
		}
		cnt -= L[tmpL] + R[tmpR];
		cnt += L[l] + R[r];
	}
	cout << ans << endl;
}