import std.stdio;
import std.string;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
import std.ascii;
import std.concurrency;
void times(alias fun)(int n) {
    foreach(i; 0..n) fun();
}
auto rep(alias fun, T = typeof(fun()))(int n) {
    T[] res = new T[n];
    foreach(ref e; res) e = fun();
    return res;
}

void main() {
    int N; long K;
    readf("%d %d\n", &N, &K);
    long[] as = N.rep!(() => readln.chomp.to!long);

    long[] bs = new long[N+1];
    foreach(i; 0..N) {
        bs[i+1] = bs[i]+as[i]-K;
    }

    // 転倒数
    
    size_t[long] aa;
    bs.dup.sort!"a<b".uniq.enumerate.each!(a => aa[a.value] = a.index);

    size_t[] cs = bs.map!(b => aa[b]).array;

    auto tree = SegTree!(long, (a, b) => a+b, 0L)(N+1);
    N.iota.map!((i) {
        tree.update(cs[i], tree.query(cs[i], cs[i]+1) + 1);
        return tree.query(0, cs[i+1]+1);
    }).sum.writeln;
}

// SegTree (Segment Tree)
struct SegTree(T, alias fun, T initValue)
    if (is(typeof(fun(T.init, T.init)) : T)) {

private:
    Node[] _data;
    size_t _size;
    size_t _l, _r;

public:
    // size ... データ数
    // initValue ... 初期値(例えばRMQだとINF)
    this(size_t size) {
        init(size);
    }

    // 配列で指定
    this(T[] ary) {
        init(ary.length);
        update(ary);
    }

    // O(N)
    void init(size_t size){
        _size = 1;
        while(_size < size) {
            _size *= 2;
        }
        _data.length = _size*2-1;
        _data[] = Node(size_t.max, initValue);
        _l = 0;
        _r = size;
    }

    // i番目の要素をxに変更
    // O(logN)
    void update(size_t i, T x) {
        size_t index = i;
        i += _size-1;
        _data[i] = Node(index, x);
        while(i>0) {
            i = (i-1)/2;
            Node vl = _data[i*2+1];
            Node vr = _data[i*2+2];
            _data[i] = fun(vl.value, vr.value) == vl.value ? vl : vr;
        }
    }

    // 配列で指定
    // O(N)
    void update(T[] ary) {
        foreach(size_t i, e; ary) {
            size_t _i = i+_size-1;
            _data[_i] = Node(i, e);
        }
        foreach(i; (_size-1).iota.retro) {
            size_t _i = _size-i-2;
            Node vl = _data[_i*2+1];
            Node vr = _data[_i*2+2];
            _data[_i] = fun(vl.value, vr.value) ==vl.value ? vl : vr;
        }
    }

    // 区間[a, b)でのクエリ (値の取得)
    // O(logN)
    T query(size_t a, size_t b) {
        return queryRec(a, b, 0, 0, _size).value;
    }

    // 区間[a, b)でのクエリ (indexの取得)
    // O(logN)
    size_t queryIndex(size_t a, size_t b) {
        return queryRec(a, b, 0, 0, _size).index;
    }

    private Node queryRec(size_t a, size_t b, size_t k, size_t l, size_t r) {
        if (b<=l || r<=a) return Node(size_t.max, initValue);
        if (a<=l && r<=b) return _data[k];
        Node vl = queryRec(a, b, k*2+1, l, (l+r)/2);
        Node vr = queryRec(a, b, k*2+2, (l+r)/2, r);
        return fun(vl.value, vr.value) == vl.value ? vl : vr;
    }

    // O(1)
    T get(size_t i) {
        return _data[_size-1 + i].value;
    }

    // O(N)
    T[] array() {
        return _data[_l+_size-1.._r+_size-1].map!"a.value".array;
    }

private:
    struct Node {
        size_t index;
        T value;
    }
}
