Problem:
Score : 600 points

Problem Statement

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.

Sample Input 1

3 6
7
5
7

Sample Output 1

5

All the non-empty contiguous subsequences of a are listed below:

{a_1} = {7}

{a_1, a_2} = {7, 5}

{a_1, a_2, a_3} = {7, 5, 7}

{a_2} = {5}

{a_2, a_3} = {5, 7}

{a_3} = {7}

Their means are 7, 6, 19/3, 5, 6 and 7, respectively, and five among them are 6 or greater. Note that {a_1} and {a_3} are indistinguishable by the values of their elements, but we count them individually.

Sample Input 2

1 2
1

Sample Output 2

0

Sample Input 3

7 26
10
20
30
40
30
20
10

Sample Output 3

13

Solution in Ruby (2.3.3) (judge verdict: Accepted)

class BIT
  attr_reader :original_size, :op, :array
  def initialize(original_size, unit, &op)
    @original_size = original_size
    @op = op
    @unit = unit
    @array = Array.new(original_size+1, unit)
  end

  def add(i, v)
    i += 1
    while i <= @original_size do
      @array[i] = @op.call(@array[i], v)
      i += i&(-i)
    end
  end

  def find(i)
    r = @unit
    i += 1
    while i > 0 do
      r = @op.call(r, @array[i])
      i = i & (i-1)
    end
    r
  end
end

N,K,*A = `dd`.split.map &:to_i
ss = [0]
A.each{ |a| ss << ss[-1] + a - K }
smap = {}
ss[1..-1].sort.each_with_index{ |s,i| smap[s] = i }

st = BIT.new(N, 0) { |a,b| a + b }
ans = 0
ct = {}
ss[1..-1].each{ |s|
  ans += 1 if s >= 0
  i = smap[s]
  ans += st.find(i)
  st.add(i, 1)
}
p ans