private static String[] assembler(ArrayList<String>[] parser) {
		String[] assemblyCodeInstructions = new String[parser.length];
		for (int i = 0; i < assemblyCodeInstructions.length; i++) {
			String func = "000000000000";
			String op;
			String reg1;
			String reg2;
			String writeReg;
			String command = parser[i].get(0);

			switch (command) {
			// a
			case "sum":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0000";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			case "mul":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0001";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			case "div":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0010";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			case "sge":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0011";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			case "sle":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0100";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			case "and":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0101";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			case "or":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0110";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			case "eq":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0111";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			// b
			case "sumi":
				op = "0001";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;
				break;
			case "ld":
				op = "0010";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;
				break;
			case "st":
				op = "0011";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;

				break;
			case "muli":
				op = "0100";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;

				break;
			case "divi":
				op = "0101";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;

				break;
			case "inc":
				op = "0110";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;

				break;
			case "clr":
				op = "0111";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;

				break;
			case "set":
				op = "1000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;

				break;
			// c
			case "not":
				op = "1001";
				reg1 = regAddress(parser[i].get(1));
				func += func;
				assemblyCodeInstructions[i] = op + reg1 + func;

				break;
			case "neg":
				op = "1010";
				reg1 = regAddress(parser[i].get(1));
				func += func;
				assemblyCodeInstructions[i] = op + reg1 + func;

				break;
			// d
			case "skp":
				op = "1011";
				reg1 = regAddress(parser[i].get(1));
				func += func; // dummy func
				assemblyCodeInstructions[i] = op + reg1 + func;

				break;// don't care ?
			case "jmp":
				op = "1100";
				func = "00000000";
				String address = parser[i].get(1);
				assemblyCodeInstructions[i] = op + func + makeItTweny("" + findInParser(parser, address)); // not

				break;
			default:
				assemblyCodeInstructions[i] = "11111111111111111111111111111111";
			}

		}

		return assemblyCodeInstructions;

	}

	private static int findInParser(ArrayList<String>[] parser, String address) {
		for (int i = 0; i < parser.length; i++) {
			if (parser[i].get(0).equals(address))
				return i;
		}
		return -1;
	}

	private static String regAddress(String regName) {
		switch (regName) {
		case "g0":
			return "0000";
		case "g1":
			return "0001";
		case "g2":
			return "0010";
		case "g3":
			return "0011";
		case "g4":
			return "0100";
		case "g5":
			return "0101";
		case "g6":
			return "0110";
		case "g7":
			return "0111";
		case "sp":
			return "1000";
		case "p0":
			return "1001";
		case "p1":
			return "1010";
		case "p2":
			return "1011";
		case "p3":
			return "1100";
		case "r0":
			return "1101";
		case "zero":
			return "1110";
		case "pc":
			return "1111";

		}
		return "wrongRegName";
	}

	private static String makeItTweny(String i) {
		String s = Integer.toBinaryString(Integer.parseInt(i));
		while (s.length() < 20)
			s = "0" + s;
		return s;
	}

	private static ArrayList<String>[] parser(Scanner sc) {
		ArrayList<String> temp = new ArrayList<String>();

		while (sc.hasNextLine()) {
			temp.add(sc.nextLine());
		}
		ArrayList<String> returned[] = (ArrayList<String>[]) new ArrayList[temp.size()];
		for (int i = 0; i < returned.length; i++) {
			// System.out.println(temp.get(i));

			String[] s = temp.get(i).split(" ");
			System.out.println(temp.get(i));
			returned[i] = new ArrayList<String>();
			for (int j = 0; j < s.length; j++) {

				returned[i].add(s[j]);
			}
		}

		return returned;
	}