



from sklearn.neural_network import MLPClassifier

__UpperCAmelCase      :      str   					=					[[0.0, 0.0], [1.0, 1.0], [1.0, 0.0], [0.0, 1.0]]
__UpperCAmelCase      :      Any   					=					[0, 1, 0, 0]


__UpperCAmelCase      :      List[str]   					=					MLPClassifier(
    solver='lbfgs', alpha=1E-5, hidden_layer_sizes=(5, 2), random_state=1
)

clf.fit(X, y)


__UpperCAmelCase      :      Union[str, Any]   					=					[[0.0, 0.0], [0.0, 1.0], [1.0, 1.0]]
__UpperCAmelCase      :      Optional[Any]   					=					clf.predict(test)
def      A      (			_A							):




					"""simple docstring"""
					return list(_A							)


if __name__ == "__main__":
				import doctest

				doctest.testmod()






"""simple docstring"""






def      A      (			_A,     _A							):




					"""simple docstring"""
					if n == 0:
										return 1

					elif n % 2 == 1:
										return binary_exponentiation(_A,     n - 1							) * a

					else:
										snake_case_						:Optional[int]								=						binary_exponentiation(_A,     n / 2							)
										return b * b


if __name__ == "__main__":
				try:
								__UpperCAmelCase      :      str   					=					int(input('Enter Base : ').strip())
								__UpperCAmelCase      :      Any   					=					int(input('Enter Power : ').strip())
				except ValueError:
								print('Invalid literal for integer')

				__UpperCAmelCase      :      Optional[int]   					=					binary_exponentiation(BASE, POWER)
				print(F'''{BASE}^({POWER}) : {RESULT}''')

