#include<iostream>
#include<vector>
#include<algorithm>
#include<utility>
#include<cstdint>
using namespace std;

template <typename T> class AVLTree {
	private:
		bool hasValue;
		AVLTree *left;
		AVLTree *right;
		T value;
		int height;
		int count;
		void cng(AVLTree<T> *t);
		void calc();
		void rotateLeft();
		void rotateRight();
		void rotate();
	public:
		AVLTree();
		void set(T n);
		bool search(T n);
		T get(int n);
		T getMin();
		T getMax();
		int getSmaller(T n);
		int getGreater(T n);
		int getSize();
		bool remove(T n);
		bool removeMin();
		bool removeMax();
		void clear();
		bool isEmpty();
		void getList(vector<T> &l);
};

template <typename T> AVLTree<T>::AVLTree() {
	clear();
}

template <typename T> void AVLTree<T>::calc() {
	if (isEmpty()) return;
	height = max(left->height, right->height) + 1;
	count = left->count + right->count + 1;
}

template <typename T> void AVLTree<T>::cng(AVLTree<T> *t) {
	swap(left, t->left);
	swap(right, t->right);
	swap(value, t->value);
}

template <typename T> void AVLTree<T>::rotateLeft() {
	AVLTree *tmp = right, *tmp2 = right->left;
	cng(right);
	left = tmp;
	left->right = tmp2;
	left->calc();
	calc();
}

template <typename T> void AVLTree<T>::rotateRight() {
	AVLTree *tmp = left, *tmp2 = left->right;
	cng(left);
	right = tmp;
	right->left = tmp2;
	right->calc();
	calc();
}

template <typename T> void AVLTree<T>::rotate() {
	if (isEmpty()) return;
	if (left->height > right->height + 1) {
		if (left->left->height < left->right->height) left->rotateLeft();
		rotateRight();
	} else if (left->height + 1 < right->height) {
		if (right->left->height > right->right->height) right->rotateRight();
		rotateLeft();
	}
	calc();
}

template <typename T> void AVLTree<T>::set(T n) {
	if (isEmpty()) {
		hasValue = true;
		value = n;
		left = new AVLTree<T>;
		right = new AVLTree<T>;
	} else if (n < value) {
		left->set(n);
	} else {
		right->set(n);
	}
	rotate();
}

template <typename T> bool AVLTree<T>::search(T n) {
	if (!hasValue) return false;
	else if (value == n) return true;
	else if (value < n) return left->search(n);
	else return right->search(n);
}

template <typename T> T AVLTree<T>::get(int n) {
	if (isEmpty()) return 0;
	else if (n < left->count) return left->get(n);
	else if (n == left->count) return value;
	else return right->get(n - left->count - 1);
}

template <typename T> T AVLTree<T>::getMin() {
	return left->hasValue ? left->getMin() : value;
}

template <typename T> T AVLTree<T>::getMax() {
	return right->hasValue ? right->getMax() : value;
}

template <typename T> int AVLTree<T>::getSmaller(T n) {
	if (isEmpty()) return 0;
	else if (n < value) return left->getSmaller(n);
	return left->count + 1 + right->getSmaller(n);
}

template <typename T> int AVLTree<T>::getGreater(T n) {
	if (isEmpty()) return 0;
	else if (n > value) return right->getGreater(n);
	return left->getGreater(n) + 1 + right->count;
}

template <typename T> int AVLTree<T>::getSize() {
	return count;
}

template <typename T> bool AVLTree<T>::remove(T n) {
	if (isEmpty()) return false;
	if (n < value) return left->remove(n);
	else if (n > value) return right->remove(n);
	else {
		right->remove(n);
		left->remove(n);
		if (left->hasValue) {
			value = left->getMax();
			if (!left->removeMax()) left = left->left;
		} else if (right->hasValue) {
			value = right->getMin();
			if (!right->removeMin()) right = right->right;
		} else clear();
	}
	rotate();
	return true;
}

template <typename T> bool AVLTree<T>::removeMin() {
	if (isEmpty() || !left->hasValue) return false;
	if (!left->left->hasValue) {
		left = left->right;
		return true;
	}
	return left->removeMin();
}

template <typename T> bool AVLTree<T>::removeMax() {
	if (isEmpty() || !right->hasValue) return false;
	if (!right->right->hasValue) {
		right = right->left;
		return true;
	}
	return right->removeMax();
}

template <typename T> void AVLTree<T>::clear() {
	hasValue = false;
	height = 0;
	count = 0;
	left = NULL;
	right = NULL;
}

template <typename T> bool AVLTree<T>::isEmpty() {
	return !hasValue;
}

template <typename T> void AVLTree<T>::getList(vector<T> &l) {
	if (isEmpty()) return;
	left->getList(l);
	l.push_back(value);
	right->getList(l);
}

const int MAX = 200001;
int main() {
	static int N, K, a[MAX];
	cin >> N >> K;
	for (int i = 0;i < N;i ++) cin >> a[i];
	static int64_t b[MAX];
	b[0] = 0;
	for (int i = 1;i <= N;i ++) {
		b[i] = b[i - 1] + a[i - 1] - K;
	}
	
	static AVLTree<int64_t> tree;
	int64_t ans = 0;
	for (int i = 0;i <= N;i ++) {
		tree.set(b[i]);
		ans += tree.getSmaller(b[i]) - 1;
	}
	cout << ans;
	return 0;
}
/*
31536000のコメント解説欄
ここテンプレで用意してるから、A問題とかだとこの先空欄の危険あり
また、コンテスト後に https://31536000.hatenablog.com/ で解説していると思うので、良かったら読んでねー

まず、単調性さえあればこの手の問題は尺取り法で解ける
この問題は、算術平均……つまり、長さで割るせいで単調性の判断ができないのが最大の問題
まずここを解消したい

求めるべきはΣ[i=l, r-1]a_i ≧ (r - l)K
→Σ[i=0, r-1]a_i - Σ[i=0, l - 1]a_i ≧ (r - l)K (累積和の考え方)
→Σ[i=0, r-1]bA_i - rK ≧ Σ[i=0, l - 1]a_i - lK (対称な形に)
おっと、これは……仮にb_i = Σ[j=0, i - 1]a_j - iKとしようか
b_0 = 0, b_i = b_{i-1} + a_{i - 1} - Kかな
これはb_r ≧ b_l (l < r)を列挙すれば良いことになる

さて、これをどうやって列挙するかだが、これはb_rのデータ追加O(logN)、b_l以下探索O(logN)であれば良い訳だ
このアルゴリズムはどう考えても二分探索木なのでライブラリを持ってこよう
*/

Measured memory_bytes: 21376