Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.

Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.

More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.

Input

The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).

The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.

Output

Print the number of segments in Petya's array with the sum of elements less than t.

Examples

Input

5 4
5 -1 3 4 -1


Output

5


Input

3 0
-1 2 -3


Output

4


Input

4 -1
-2 1 -2 3


Output

3

Note

In the first example the following segments have sum less than 4:

  * [2, 2], sum of elements is -1 
  * [2, 3], sum of elements is 2 
  * [3, 3], sum of elements is 3 
  * [4, 5], sum of elements is 3 
  * [5, 5], sum of elements is -1 

import java.io.*;
import java.math.BigInteger;
import java.util.*;


public class Main {

	static long sx = 0, sy = 0, mod = (long) (1e9 + 7);

	// static ArrayList<Integer>[] a;
	static long[][][] dp;
	static long[] fa;
	static long[] farr;
	public static PrintWriter out;
	static ArrayList<pair> pa = new ArrayList<>();
	static long[] fact = new long[(int) 1e6];
	static StringBuilder sb = new StringBuilder();
	static boolean cycle = false;
	static long m = 998244353;
	static long[] no, col;
	// static String s;
	static int k = 0, n = 0;
	static int[] c;
	static long ans = 0;
	static HashMap<Integer, Integer> hm;
	static long[] arr;;
	static int[] depth;
	static int[] a;
	static int[][] p;
	static int[][] s;

	public static void main(String[] args) throws IOException {

//		Scanner scn = new Scanner(new BufferedReader(new InputStreamReader(System.in)));

		out = new PrintWriter(System.out);
		 Reader scn = new Reader();

		int n = scn.nextInt();
		
		long t = scn.nextLong();
		
		 long []a = new long[n+1];
		 
		 
		 for(int i=1; i<=n; i++)
			  a[i] = scn.nextLong();
		 
		 for(int i=1; i<=n; i++)
			   a[i]+=a[i-1];
		 
		 
		 
		 segment s = new segment(a);

		 long ans = 0;
		 
		 for(int i=1; i<=n; i++){
			 
			  ans+=s.query(0, i-1, a[i]-t);
			  
//			  System.out.println(ans);
		 }
		 
		 System.out.println(ans);
	

	}
	
	private static class segment {

		private static class node {

			long[] a;
			int si;
			int ei;
			node left, right;
		}

		node root;

		public segment(long[] a) {

			root = Construct(a, 0, a.length - 1);
		}

		private node Construct(long[] a, int si, int ei) {

			if (si == ei) {
				node bn = new node();
				bn.si = si;
				bn.ei = ei;

				long[] ba = { a[si] };
				bn.a = ba;
				return bn;
			}

			node n = new node();
			int mid = (si + ei) / 2;
			n.si = si;
			n.ei = ei;
			n.left = Construct(a, si, mid);
			n.right = Construct(a, mid + 1, ei);
			n.a = merge(n.left.a, n.right.a);

			return n;
		}

		public int query(int si, int ei, long k) {
			return query(root, si, ei, k);
		}

		private int query(node n, int si, int ei, long k) {

			if (n.si >= si && n.ei <= ei) {
				return count(n.a, k);
			}

			else if (n.si > ei || n.ei < si)
				return 0;

			else {

				return query(n.left, si, ei, k) + query(n.right, si, ei, k);
			}

		}

		private int count(long[] a, long k) {

			 if(a.length == 1){
				 
				  if(k < a[0])
					   return 1;
				  return 0;
			 }
			if (k < a[0])
				return a.length;

			if (k >= a[a.length - 1])
				return 0;

			int lo = 0, hi = a.length - 1;
			int ans = 0;

			while (lo <= hi) {

				int mid = (lo + hi) / 2;

				if (a[mid] > k) {

					ans = mid;
					hi = mid - 1;
				}

				else
					lo = mid + 1;
			}

			return a.length-ans;
		}

		private long[] merge(long[] a, long[] b) {

			long[] c = new long[a.length + b.length];

			int i = 0, j = 0, k = 0;

			while (i < a.length && j < b.length) {

				if (a[i] < b[j])
					c[k++] = a[i++];
				else
					c[k++] = b[j++];
			}

			while (i < a.length)
				c[k++] = a[i++];

			while (j < b.length)
				c[k++] = b[j++];
			return c;
		}
	}

	// _________________________TEMPLATE_____________________________________________________________

	// public static long lcm(long x, long y) {
	//
	// return (x * y) / gcd(x, y);
	// }
	//
	// private static long gcd(long x, long y) {
	// if (x == 0)
	// return y;
	//
	// return gcd(y % x, x);
	// }
	//
	// static class comp implements Comparator<pair> {
	//
	// @Override
	// public int compare(pair p1, pair p2) {
	// return p1.i - p2.i;
	// }
	//
	// }
	//
	// public static long pow(long a, long b) {
	//
	// if (b < 0)
	// return 0;
	// if (b == 0 || b == 1)
	// return (long) Math.pow(a, b);
	//
	// if (b % 2 == 0) {
	//
	// long ret = pow(a, b / 2);
	// ret = (ret % mod * ret % mod) % mod;
	// return ret;
	// }
	//
	// else {
	// return ((pow(a, b - 1) % mod) * a % mod) % mod;
	// }
	// }

	private static class pair implements Comparable<pair> {

		long no;
		long s, e;

		pair(long n, long c, long d) {
			no = n;
			s = c;
			e = d;

		}

		@Override
		public int compareTo(pair o) {

			return 1;

		}

		// @Override
		//
		// public int hashCode() {
		// return i;
		// }
		//
		// @Override
		//
		// public boolean equals(Object o) {
		//
		// pair p = (pair) o;
		// return this.i == p.i;
		// }

	}

	private static String reverse(String s) {

		return new StringBuilder(s).reverse().toString();
	}

	public static class Reader {
		final private int BUFFER_SIZE = 1 << 16;
		private DataInputStream din;
		private byte[] buffer;
		private int bufferPointer, bytesRead;

		public Reader() {
			din = new DataInputStream(System.in);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public Reader(String file_name) throws IOException {
			din = new DataInputStream(new FileInputStream(file_name));
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public String readLine() throws IOException {
			byte[] buf = new byte[1000000 + 1]; // line length
			int cnt = 0, c;
			while ((c = read()) != -1) {
				if (c == '\n')
					break;
				buf[cnt++] = (byte) c;
			}
			return new String(buf, 0, cnt);
		}

		public int nextInt() throws IOException {
			int ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do {
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');

			if (neg)
				return -ret;
			return ret;
		}

		public long nextLong() throws IOException {
			long ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do {
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');
			if (neg)
				return -ret;
			return ret;
		}

		public double nextDouble() throws IOException {
			double ret = 0, div = 1;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();

			do {
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');

			if (c == '.') {
				while ((c = read()) >= '0' && c <= '9') {
					ret += (c - '0') / (div *= 10);
				}
			}

			if (neg)
				return -ret;
			return ret;
		}

		private void fillBuffer() throws IOException {
			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
			if (bytesRead == -1)
				buffer[0] = -1;
		}

		private byte read() throws IOException {
			if (bufferPointer == bytesRead)
				fillBuffer();
			return buffer[bufferPointer++];
		}

		public void close() throws IOException {
			if (din == null)
				return;
			din.close();
		}

		public int[] nextIntArray(int n) throws IOException {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextInt();
			}
			return arr;
		}

		public long[] nextLongArray(int n) throws IOException {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextLong();
			}
			return arr;
		}

		public int[][] nextInt2DArray(int m, int n) throws IOException {
			int[][] arr = new int[m][n];
			for (int i = 0; i < m; i++) {
				for (int j = 0; j < n; j++)
					arr[i][j] = nextInt();
			}
			return arr;
		}

		public long[][] nextInt2DArrayL(int m, int n) throws IOException {
			long[][] arr = new long[m][n];
			for (int i = 0; i < m; i++) {
				for (int j = 0; j < n; j++)
					arr[i][j] = nextInt();
			}
			return arr;
		}
		// kickstart - Solution
		// atcoder - Main
	}

}