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.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.*;
import java.util.Map.Entry;

public class Main
{
	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;
	private PrintWriter pw;
	private long mod = 1000000000
			+ 7;

	private StringBuilder ans_sb;

	private void soln()
	{
		int n = nextInt();
		long t = nextLong();
		long[] arr = new long[n
				+ 1];
		TreeSet<Long> map = new TreeSet<>();
		map.add(0L);
		map.add(t);
		long sum = 0;
		for (int i = 0; i < n; i++)
		{
			arr[i] = nextLong();
			sum += arr[i];
			map.add(sum);
			// map.add(sum+t);
			map.add(sum
					- t);
		}
		HashMap<Long, Integer> map1 = new HashMap<>();
		int k = 0;
		for (long x : map)
		{
			map1.put(
					x,
					k++);
		}
		// debug(map);
		Segment tree = new Segment(
				k);
		tree.update(
				map1.get(
						0L),
				map1.get(
						0L),
				1);
		// debug(map1);
		sum = 0;
		long ans = 0;
		for (int i = 0; i < n; i++)
		{
			sum += arr[i];
			long sum1 = sum
					- t;
			int ti1 = map1
					.get(sum1);
			// debug(ti1);
			ans += tree
					.query(ti1
							+ 1,
							k);
			int idx = map1
					.get(sum);
			// debug(idx);
			tree.update(
					idx,
					idx,
					1);
			// debug(ans);
		}
		pw.println(
				ans);
	}

	public class Segment
	{
		private Node[] tree;
		private boolean[] lazy;
		private int size;
		private int n;

		private class Node
		{
			private long ans;
		}

		public Segment(
				int n)
		{
			// this.base=arr;
			int x = (int) (Math
					.ceil(Math
							.log(n)
							/ Math.log(
									2)));
			size = 2 * (int) Math
					.pow(2, x)
					- 1;
			tree = new Node[size];
			lazy = new boolean[size];
			this.n = n;
			// this.set = set1;
			build(0, 0,
					n - 1);
		}

		public void build(
				int id,
				int l,
				int r)
		{
			if (l == r)
			{
				tree[id] = new Node();
				return;
			}
			int mid = ((l
					+ r) >> 1);
			build((id << 1)
					| 1,
					l,
					mid);
			build((id << 1)
					+ 2,
					mid + 1,
					r);
			tree[id] = merge(
					tree[(id << 1)
							| 1],
					tree[(id << 1)
							+ 2]);
			// System.out.println(l+" "+r+" "+tree[id].l+" "+tree[id].r+" "+tree[id].ans);
		}

		public Node merge(
				Node n1,
				Node n2)
		{
			Node ret = new Node();
			if (n1 == null
					&& n2 == null)
				return null;
			else if (n1 == null)
			{
				ret.ans = n2.ans;
			} else if (n2 == null)
			{
				ret.ans = n1.ans;
			} else
			{
				ret.ans = n1.ans
						+ n2.ans;
			}
			return ret;
		}

		public long query(
				int l,
				int r)
		{
			Node ret = queryUtil(
					l,
					r,
					0,
					0,
					n - 1);
			if (ret == null)
			{
				return 0;
			} else
				return ret.ans;
		}

		private Node queryUtil(
				int x,
				int y,
				int id,
				int l,
				int r)
		{
			if (l > y
					|| x > r)
				return null;
			if (x <= l
					&& r <= y)
			{
				return tree[id];
			}
			int mid = ((l
					+ r) >> 1);
			// shift(id);
			Node q1 = queryUtil(
					x,
					y,
					(id << 1)
							| 1,
					l,
					mid);
			Node q2 = queryUtil(
					x,
					y,
					(id << 1)
							+ 2,
					mid + 1,
					r);
			return merge(
					q1,
					q2);
		}

		public void update(
				int x,
				int y,
				int c)
		{
			update1(x,
					y,
					c,
					0,
					0,
					n - 1);
		}

		private void update1(
				int x,
				int y,
				int colour,
				int id,
				int l,
				int r)
		{
			// System.out.println(l+" "+r+" "+x);
			if (x > r
					|| y < l)
				return;
			if (x <= l
					&& r <= y)
			{
				tree[id].ans += colour;
				return;
			}
			int mid = ((l
					+ r) >> 1);
			// shift(id);
			if (y <= mid)
				update1(x,
						y,
						colour,
						(id << 1)
								| 1,
						l,
						mid);
			else if (x > mid)
				update1(x,
						y,
						colour,
						(id << 1)
								+ 2,
						mid + 1,
						r);
			else
			{
				update1(x,
						y,
						colour,
						(id << 1)
								| 1,
						l,
						mid);
				update1(x,
						y,
						colour,
						(id << 1)
								+ 2,
						mid + 1,
						r);
			}
			tree[id] = merge(
					tree[(id << 1)
							| 1],
					tree[(id << 1)
							+ 2]);

		}
	}

	private String solveEqn(
			long a,
			long b)
	{
		long x = 0,
				y = 1,
				lastx = 1,
				lasty = 0,
				temp;
		while (b != 0)
		{
			long q = a
					/ b;
			long r = a
					% b;
			a = b;
			b = r;
			temp = x;
			x = lastx
					- q * x;
			lastx = temp;
			temp = y;
			y = lasty
					- q * y;
			lasty = temp;
		}
		return lastx
				+ " "
				+ lasty;
	}

	private void debug(
			Object... o)
	{
		System.out
				.println(
						Arrays.deepToString(
								o));
	}

	private long pow(
			long a,
			long b,
			long c)
	{
		if (b == 0)
			return 1;
		long p = pow(
				a,
				b / 2,
				c);
		p = (p * p)
				% c;
		return (b
				% 2 == 0)
						? p
						: (a * p)
								% c;
	}

	private long gcd(
			long n,
			long l)
	{
		if (l == 0)
			return n;
		return gcd(
				l,
				n % l);
	}

	public static void main(
			String[] args)
			throws Exception
	{
		new Thread(
				null,
				new Runnable()
				{
					@Override
					public void run()
					{
						new Main()
								.solve();
					}
				},
				"1",
				1 << 26).start();
		// new Main().solve();
	}

	public StringBuilder solve()
	{
		InputReader(
				System.in);
		/*
		 * try { InputReader(new FileInputStream("C:\\Users\\hardik\\Desktop\\in.txt"));
		 * } catch(FileNotFoundException e) {}
		 */
		pw = new PrintWriter(
				System.out);
		// ans_sb = new StringBuilder();
		soln();

		pw.close();
		// System.out.println(ans_sb);
		return ans_sb;
	}

	public void InputReader(
			InputStream stream1)
	{
		stream = stream1;
	}

	private boolean isWhitespace(
			int c)
	{
		return c == ' '
				|| c == '\n'
				|| c == '\r'
				|| c == '\t'
				|| c == -1;
	}

	private boolean isEndOfLine(
			int c)
	{
		return c == '\n'
				|| c == '\r'
				|| c == -1;
	}

	private int read()
	{
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars)
		{
			curChar = 0;
			try
			{
				numChars = stream
						.read(buf);
			} catch (IOException e)
			{
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	private int nextInt()
	{
		int c = read();
		while (isSpaceChar(
				c))
			c = read();
		int sgn = 1;
		if (c == '-')
		{
			sgn = -1;
			c = read();
		}
		int res = 0;
		do
		{
			if (c < '0'
					|| c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(
				c));
		return res
				* sgn;
	}

	private long nextLong()
	{
		int c = read();
		while (isSpaceChar(
				c))
			c = read();
		int sgn = 1;
		if (c == '-')
		{
			sgn = -1;
			c = read();
		}
		long res = 0;
		do
		{
			if (c < '0'
					|| c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(
				c));
		return res
				* sgn;
	}

	private String nextToken()
	{
		int c = read();
		while (isSpaceChar(
				c))
			c = read();
		StringBuilder res = new StringBuilder();
		do
		{
			res.appendCodePoint(
					c);
			c = read();
		} while (!isSpaceChar(
				c));
		return res
				.toString();
	}

	private String nextLine()
	{
		int c = read();
		while (isSpaceChar(
				c))
			c = read();
		StringBuilder res = new StringBuilder();
		do
		{
			res.appendCodePoint(
					c);
			c = read();
		} while (!isEndOfLine(
				c));
		return res
				.toString();
	}

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

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

	private void pArray(
			int[] arr)
	{
		for (int i = 0; i < arr.length; i++)
		{
			System.out
					.print(arr[i]
							+ " ");
		}
		System.out
				.println();
		return;
	}

	private void pArray(
			long[] arr)
	{
		for (int i = 0; i < arr.length; i++)
		{
			System.out
					.print(arr[i]
							+ " ");
		}
		System.out
				.println();
		return;
	}

	private boolean isSpaceChar(
			int c)
	{
		if (filter != null)
			return filter
					.isSpaceChar(
							c);
		return isWhitespace(
				c);
	}

	private char nextChar()
	{
		int c = read();
		while (isSpaceChar(
				c))
			c = read();
		char c1 = (char) c;
		while (!isSpaceChar(
				c))
			c = read();
		return c1;
	}

	private interface SpaceCharFilter
	{
		public boolean isSpaceChar(
				int ch);
	}
}