You are given an integer sequence $a_1, a_2, \dots, a_n$.

Find the number of pairs of indices $(l, r)$ ($1 \le l \le r \le n$) such that the value of median of $a_l, a_{l+1}, \dots, a_r$ is exactly the given number $m$.

The median of a sequence is the value of an element which is in the middle of the sequence after sorting it in non-decreasing order. If the length of the sequence is even, the left of two middle elements is used.

For example, if $a=[4, 2, 7, 5]$ then its median is $4$ since after sorting the sequence, it will look like $[2, 4, 5, 7]$ and the left of two middle elements is equal to $4$. The median of $[7, 1, 2, 9, 6]$ equals $6$ since after sorting, the value $6$ will be in the middle of the sequence.

Write a program to find the number of pairs of indices $(l, r)$ ($1 \le l \le r \le n$) such that the value of median of $a_l, a_{l+1}, \dots, a_r$ is exactly the given number $m$.
The first line contains integers $n$ and $m$ ($1 \le n,m \le 2\cdot10^5$) — the length of the given sequence and the required value of the median.

The second line contains an integer sequence $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 2\cdot10^5$).
5 4
1 4 5 60 4
8
3 1
1 1 1
6
15 2
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3
97
1 1
1
1
2 1
1 2
2
2 1
2 1
2
2 2
1 2
1
2 2
2 1
1
3 1
1 2 3
2
3 1
1 3 2
2
3 1
2 1 3
3
3 1
2 3 1
2
3 1
3 1 2
3
3 1
3 2 1
2
2 2
1 1
0
3 2
1 1 2
1
2 1
1 1
3
1 1
2
0
2 2
4 1
0
3 3
5 5 3
2
4 3
3 5 2 3
6
5 2
1 9 2 8 10
5
6 5
7 2 11 8 9 12
0
7 5
14 4 1 11 12 3 4
0
8 2
2 6 11 14 10 9 9 5
2
9 8
10 8 8 15 1 2 13 8 6
27
10 7
14 20 3 3 8 16 17 13 6 4
0
1 200000
1
0
1 200000
200000
1
class BIT:
    def __init__(self, n):
        self.n = n
        self.bit = [0]*(self.n+1) # 1-indexed

    def init(self, init_val):
        for i, v in enumerate(init_val):
            self.add(i, v)

    def add(self, i, x):
        # i: 0-indexed
        i += 1 # to 1-indexed
        while i <= self.n:
            self.bit[i] += x
            i += (i & -i)

    def sum(self, i, j):
        # return sum of [i, j)
        # i, j: 0-indexed
        return self._sum(j) - self._sum(i)

    def _sum(self, i):
        # return sum of [0, i)
        # i: 0-indexed
        res = 0
        while i > 0:
            res += self.bit[i]
            i -= i & (-i)
        return res

    def lower_bound(self, x):
        s = 0
        pos = 0
        depth = self.n.bit_length()
        v = 1 << depth
        for i in range(depth, -1, -1):
            k = pos + v
            if k <= self.n and s + self.bit[k] < x:
                    s += self.bit[k]
                    pos += v
            v >>= 1
        return pos

    def __str__(self): # for debug
        arr = [self.sum(i,i+1) for i in range(self.n)]
        return str(arr)

def calc(m):
    res = 0
    bit = BIT(2*n+50)
    f = 0
    for i in range(n):
        bit.add(n+f, 1)
        if A[i] > m:
            f -= 1
        else:
            f += 1
        res += bit.sum(0, n+f+1)
    return res

n, m = map(int, input().split())
A = list(map(int, input().split()))
ans = calc(m)-calc(m-1)
print(ans)
