import java.util.LinkedList;

public class step1 {
	static LinkedList<node> array[];
	static LinkedList<node> remain;
	static LinkedList<node> finall_array;

	static int nOfBits = 0;
	int noRemain = 0;
	static String Binary(int decimal) {
		array = new LinkedList[nOfBits + 1];
		StringBuilder conc = new StringBuilder();
		String bin = Integer.toBinaryString(decimal);
		int count = 0;
		for (int i = 0; i < bin.length(); i++) {
			if (bin.charAt(i) == '1') {
				count++;
			}
		}
		for (int i = 0; i < nOfBits - bin.length(); i++) {
			conc.append("0");
		}
		conc.append(bin);
		node new_node = new node(2 ^ nOfBits - 1);
		new_node.minterm = conc.toString();
		new_node.min[decimal] = true;
		new_node.symbol.append(Integer.toString(decimal)).append(',');
		array[count].add(new_node);
		return conc.toString();
	}

	/**
	 * to get first simplification
	 *
	 * @param tmp
	 */
	public void solve(LinkedList<node> tmp[]) {
		tmp = array;
		LinkedList<node> tmpnext = null;
		int i = 0;
		while (i < tmp.length - 1) {
			for (int j = 0; j < tmp[i].size(); j++) {
				int take = 0;
				for (int k = 0; k < tmp[i + 1].size(); k++) {
					int count = 0;
					StringBuilder newminterm = new StringBuilder();
					for (int l = 0; l < nOfBits; l++) {

						if (tmp[i].get(j).minterm.charAt(l) == tmp[i].get(k).minterm.charAt(l)) {
							newminterm.append(tmp[i].get(j).minterm.charAt(l));
							continue;

						} else {
							count++;
							newminterm.append('-');
							if (count > 1)
								break;

						}
					}
					if (count == 1) {
						node new_node = new node(nOfBits);
						new_node.minterm = newminterm.toString();
						new_node.min[i] = true;
						new_node.symbol.append(Integer.toString(i)).append(',').append(Integer.toString(i + 1))
								.append(',');
						tmpnext.add(new_node);
						take = 1;
					}

				}
				if (take == 0) {
					node new_node = new node(nOfBits);
					new_node.minterm = tmp[i].get(j).minterm;
					new_node.symbol.append(Integer.toString(i)).append(',');
					remain.add(new_node);
					noRemain++;
				}
			}
			i++;
		}
		getdashes(tmpnext);

	}

	/**
	 * to get dashes
	 *
	 * @param dash
	 */
	public void getdashes(LinkedList<node> dash) {

		LinkedList<node> tmpdash = null;
		boolean check_ind[] = new boolean[dash.size()];
		for (int i = 0; i < dash.size(); i++) {
			int take = 0;
			if (check_ind[i] == true) {
				continue;
			}
			for (int j = 0; j < dash.size(); j++) {
				int count = 0;

				StringBuilder newminterm = new StringBuilder();
				for (int l = 0; l < nOfBits; l++) {

					if (dash.get(j).minterm.charAt(l) == dash.get(i).minterm.charAt(l)) {
						newminterm.append(dash.get(j).minterm.charAt(l));
						continue;

					} else {
						count++;
						newminterm.append('-');
						if (count > 1)
							break;

					}
				}
				if (count == 1) {
					int add = 1;
					node new_node = new node(nOfBits);
					new_node.minterm = newminterm.toString();
					new_node.symbol.append(dash.get(i).symbol).append(dash.get(j).symbol).append(',');
					if (check_ind[j] == true) {
						if (new_node.minterm == dash.get(j).minterm)
							add = 0;
					}
					if (add == 1) {
						check_ind[j] = true;
						tmpdash.add(new_node);
					}
					take = 1;
				}
			}
			if (take == 0) {
				node new_node = new node(nOfBits);
				new_node.minterm = dash.get(i).minterm;
				remain.add(new_node);
				noRemain++;
			}
		}
		finall_array = tmpdash;
		if (tmpdash.size() != 0) {
			getdashes(tmpdash);
		}

	}
}