The only difference between easy and hard versions is constraints.

A session has begun at Beland State University. Many students are taking exams.

Polygraph Poligrafovich is going to examine a group of n students. Students will take the exam one-by-one in order from 1-th to n-th. Rules of the exam are following:

  * The i-th student randomly chooses a ticket. 
  * if this ticket is too hard to the student, he doesn't answer and goes home immediately (this process is so fast that it's considered no time elapses). This student fails the exam. 
  * if the student finds the ticket easy, he spends exactly t_i minutes to pass the exam. After it, he immediately gets a mark and goes home. 



Students take the exam in the fixed order, one-by-one, without any interruption. At any moment of time, Polygraph Poligrafovich takes the answer from one student.

The duration of the whole exam for all students is M minutes (max t_i ≤ M), so students at the end of the list have a greater possibility to run out of time to pass the exam.

For each student i, you should count the minimum possible number of students who need to fail the exam so the i-th student has enough time to pass the exam.

For each student i, find the answer independently. That is, if when finding the answer for the student i_1 some student j should leave, then while finding the answer for i_2 (i_2>i_1) the student j student does not have to go home.

Input

The first line of the input contains two integers n and M (1 ≤ n ≤ 100, 1 ≤ M ≤ 100) — the number of students and the total duration of the exam in minutes, respectively.

The second line of the input contains n integers t_i (1 ≤ t_i ≤ 100) — time in minutes that i-th student spends to answer to a ticket.

It's guaranteed that all values of t_i are not greater than M.

Output

Print n numbers: the i-th number must be equal to the minimum number of students who have to leave the exam in order to i-th student has enough time to pass the exam.

Examples

Input


7 15
1 2 3 4 5 6 7


Output


0 0 0 0 0 2 3 

Input


5 100
80 40 40 40 60


Output


0 1 1 2 3 

Note

The explanation for the example 1.

Please note that the sum of the first five exam times does not exceed M=15 (the sum is 1+2+3+4+5=15). Thus, the first five students can pass the exam even if all the students before them also pass the exam. In other words, the first five numbers in the answer are 0.

In order for the 6-th student to pass the exam, it is necessary that at least 2 students must fail it before (for example, the 3-rd and 4-th, then the 6-th will finish its exam in 1+2+5+6=14 minutes, which does not exceed M).

In order for the 7-th student to pass the exam, it is necessary that at least 3 students must fail it before (for example, the 2-nd, 5-th and 6-th, then the 7-th will finish its exam in 1+3+4+7=15 minutes, which does not exceed M).
import java.util.*;
import java.io.*;

public class C {

	static final boolean stdin = true;
	static final String filename = "";
	static FastScanner br;
	static PrintWriter pw;

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

		if (stdin) {
			br = new FastScanner();
			pw = new PrintWriter(new OutputStreamWriter(System.out));
		} else {
			br = new FastScanner(filename + ".in");
			pw = new PrintWriter(new FileWriter(filename + ".out"));
		}

		Solver solver = new Solver();
		solver.solve(br, pw);
	}

	static class Solver {
		static long mod = 1000000000;

		public void solve(FastScanner br, PrintWriter pw) throws IOException {
			int n = br.nextInt(), m = br.nextInt();
			int[] times = new int[n];
			ArrayList<Integer> all = new ArrayList<Integer>();
			int tot = 0;
			for (int i = 0; i < n; i++) {
				times[i] = br.nextInt();
				Collections.sort(all);
				int out = 0;
				int tott = tot;
				int las = all.size() - 1;
				while (out != i && tott + times[i] > m) {
					tott -= all.get(las);
					las--;
					out++;
				}
				pw.print(out + " ");
				all.add(times[i]);
				tot += times[i];
			}
			pw.close();
		}

		static long gcd(long a, long b) {
			if (a > b)
				return gcd(b, a);
			if (a == 0)
				return b;
			return gcd(b % a, a);
		}

		static long pow(long a, long b) {
			if (b == 0)
				return 1L;
			long val = pow(a, b / 2);
			if (b % 2 == 0)
				return val * val % mod;
			else
				return val * val % mod * a % mod;
		}

	}

	static class Point1 implements Comparable<Point1> {
		int a;
		int b;

		Point1(int a, int b) {
			this.a = a;
			this.b = b;
		}

		@Override
		public int compareTo(Point1 o) {
			return this.a - o.a;
		}

	}

	static class Point2 implements Comparable<Point2> {
		int a;
		int b;

		Point2(int a, int b) {
			this.a = a;
			this.b = b;
		}

		@Override
		public int compareTo(Point2 o) {
			return this.b - o.b;
		}

	}

	static class UnionFind {
		// The number of elements in this union find
		private int size;
		// Used to track the size of each of the component
		private int[] sz;
		// id[i] points to the parent of i, if id[i] = i then i is a root node
		private int[] id;
		// Tracks the number of components in the union find
		private int numComponents;

		public UnionFind(int size) {
			if (size <= 0)
				throw new IllegalArgumentException("Size <= 0 is not allowed");
			this.size = numComponents = size;
			sz = new int[size];
			id = new int[size];
			for (int i = 0; i < size; i++) {
				id[i] = i; // Link to itself (self root)
				sz[i] = 1; // Each component is originally of size one
			}
		}

		// Find which component/set 'p' belongs to in amortized constant time.
		public int find(int p) {
			// Find the root of the component/set
			int root = p;
			while (root != id[root])
				root = id[root];
			// Compress the path leading back to the root.
			// Doing this operation is called "path compression"
			// and is what gives us amortized time complexity.
			while (p != root) {
				int next = id[p];
				id[p] = root;
				p = next;
			}
			return root;
		}

		// This is an alternative recursive formulation for the find method
		// public int find(int p) {
		// if (p == id[p]) return p;
		// return id[p] = find(id[p]);
		// }

		// Return whether or not the elements 'p' and
		// 'q' are in the same components/set.
		public boolean connected(int p, int q) {
			return find(p) == find(q);
		}

		// Return the size of the components/set 'p' belongs to
		public int componentSize(int p) {
			return sz[find(p)];
		}

		// Return the number of elements in this UnionFind/Disjoint set
		public int size() {
			return size;
		}

		// Returns the number of remaining components/sets
		public int components() {
			return numComponents;
		}

		// Unify the components/sets containing elements 'p' and 'q'
		public void unify(int p, int q) {
			int root1 = find(p);
			int root2 = find(q);
			// These elements are already in the same group!
			if (root1 == root2)
				return;
			// Merge smaller component/set into the larger one.
			if (sz[root1] < sz[root2]) {
				sz[root2] += sz[root1];
				id[root1] = root2;
			} else {
				sz[root1] += sz[root2];
				id[root2] = root1;
			}
			// Since the roots found are different we know that the
			// number of components/sets has decreased by one
			numComponents--;
		}
	}

	public static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner(String s) {
			try {
				br = new BufferedReader(new FileReader(s));
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

		public FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String nextToken() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(nextToken());
		}

		long nextLong() {
			return Long.parseLong(nextToken());
		}

		double nextDouble() {
			return Double.parseDouble(nextToken());
		}

		ArrayList<Integer>[] nextGraph(int nodes, int edges) {
			ArrayList<Integer>[] adj = new ArrayList[nodes];
			for (int i = 0; i < nodes; i++) {
				adj[i] = new ArrayList<Integer>();
			}
			for (int i = 0; i < edges; i++) {
				int a = nextInt() - 1;
				int b = nextInt() - 1;
				adj[a].add(b);
				adj[b].add(a);
			}
			return adj;
		}
	}
}