//rename file to Main.java
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        String str = input.readLine();
        StringTokenizer data = new StringTokenizer(str);
        int N = Integer.parseInt(data.nextToken());
        long K = Long.parseLong(data.nextToken());
        long[] prefixSums = getPrefixSumArray(input, N, K);

        long[] prefixSumsCopy = Arrays.copyOf(prefixSums, N);
        Arrays.sort(prefixSumsCopy);

        HashMap<Long, Integer> map = new HashMap<Long, Integer>();
        int idx = 0;
        for (int i = 0; i < N; i++) {
            if (i == 0 || prefixSumsCopy[i] != prefixSumsCopy[i-1]) {
                map.put(prefixSumsCopy[i], idx++);
            }
        }

        SegmentTree segmentTree = new SegmentTree(idx);
        long ans = 0;
        for (int i = 0; i < N; i++) {
            if (prefixSums[i] >= 0) ans++;
            ans += segmentTree.getCount(map.get(prefixSums[i]));
            segmentTree.add(map.get(prefixSums[i]));
        }
        System.out.println(ans);
    }

    private static long[] getPrefixSumArray(BufferedReader input, int N, long K) throws IOException {
        String str = input.readLine();
        StringTokenizer data = new StringTokenizer(str);
        long[] A = new long[N];
        for (int i = 0; i < N; i++) {
            A[i] = Long.parseLong(data.nextToken());
            A[i] -= K;
            if (i > 0) A[i] += A[i-1];
        }
        return A;
    }

    public static class SegmentTree {
        int size;
        int twiceSize;
        int[] A;

        public SegmentTree(int noOfElements) {
            this.size = nearestPowerOfTwo(noOfElements);
            twiceSize = size << 1;
            A = new int[twiceSize];
        }

        private int nearestPowerOfTwo(int x) {
            int ans = 1;
            while (ans < x) {
                ans = ans << 1;
            }
            return ans;
        }

        public long getCount(int idx) {
            //return getCount(1, size, twiceSize-1, size+idx);
            long ans = 0;
            idx += size;
            ans += A[idx];
            int prevIdx = idx;
            idx = idx >> 1;
            while (idx != 0) {
                if (prevIdx%2 == 1) ans += A[idx];
                prevIdx = idx;
                idx = idx >> 1;
            }
            return ans;
        }

        private long getCount(int root, int leftIdx, int rightIdx, int target) {
            if (root >= twiceSize) return 0;
            if (leftIdx > target) return 0;
            if (rightIdx <= target) {
                long ans = 0;
                while (root < twiceSize) {
                    ans += A[root];
                    root = (root << 1) + 1;
                }
                return ans;
            }
            int mid = (leftIdx + rightIdx)/2;
            return getCount(root << 1, leftIdx, mid, target) + getCount((root << 1) + 1, mid+1, rightIdx, target);
        }

        public void add(int idx) {
            idx += size;
            A[idx]++;
            int prevIdx = idx;
            idx = idx >> 1;
            while (idx != 0) {
                if (prevIdx%2 == 0) A[idx]++;
                prevIdx = idx;
                idx = idx >> 1;
            }
        }
    }
}