You are given an integer sequence of length N, a = {a_1, a_2, …, a_N}, and an integer K.

a has N(N+1)/2 non-empty contiguous subsequences, {a_l, a_{l+1}, …, a_r} (1 ≤ l ≤ r ≤ N). Among them, how many have an arithmetic mean that is greater than or equal to K?

Constraints

* All input values are integers.
* 1 ≤ N ≤ 2 \times 10^5
* 1 ≤ K ≤ 10^9
* 1 ≤ a_i ≤ 10^9

Input

Input is given from Standard Input in the following format:


N K
a_1
a_2
:
a_N


Output

Print the number of the non-empty contiguous subsequences with an arithmetic mean that is greater than or equal to K.

Examples

Input

3 6
7
5
7


Output

5


Input

1 2
1


Output

0


Input

7 26
10
20
30
40
30
20
10


Output

13
N, K = list(map(int, input().split()))

aa = []
for _ in range(N):
    a = int(input())
    aa.append(a - K)

raa = [0]
for a in aa:
    raa.append(raa[-1] + a)


class Searchable_BIT():
    def __init__(self, N):
        self.N = N
        self.node = [0] * (self.N + 1)
        self.cnt = 0

    def add(self, a):  # 要素 x を追加
        x = a
        self.cnt += 1
        while x <= self.N:
            self.node[x] += 1
            x += x & -x

    def delete(self, x):  # 要素 x を削除
        self.cnt -= 1
        while x <= self.N:
            self.node[x] -= 1
            x += x & -x

    def count(self, x):  # x以下の要素数
        tmp = 0
        while x > 0:
            tmp += self.node[x]
            x -= x & -x
        return tmp

    def get_maxval(self):
        return self.get_lower_i(self.cnt)

    def get_lower_i(self, i):  # i 番目に小さい要素を取得
        NG = -1
        OK = self.N
        while OK - NG > 1:
            mid = (OK + NG) // 2
            # print(OK,NG,self.count(mid))
            if self.count(mid) >= i:
                OK = mid
            else:
                NG = mid
        return OK


a2i = {a: i + 1 for i, a in enumerate(sorted(list(set(raa))))}
BIT = Searchable_BIT(len(a2i) + 5)

ans = 0
for i, a in enumerate(raa):
    ans += BIT.count(a2i[a])

    BIT.add(a2i[a])

print(ans)
