def  _lowerCamelCase					(   a_				: int						,			a_				: bool = False):




			if n == 2:
						return True
			if not n % 2 or n < 2:
						return False
			if n > 5 and n % 10 not in (1, 3, 7, 9):  # can quickly check last digit
						return False
			if n > 3_31_70_44_06_46_79_88_73_85_96_19_81 and not allow_probable:
						raise ValueError(
						    '''Warning: upper bound of deterministic test is exceeded. '''
						    '''Pass allow_probable=True to allow probabilistic test. '''
						    '''A return value of True indicates a probable prime.''')
			# array bounds provided by analysis
			lowerCamelCase						:Any						  =     [
			    20_47,
			    1_37_36_53,
			    25_32_60_01,
			    32_15_03_17_51,
			    2_15_23_02_89_87_47,
			    3_47_47_49_66_03_83,
			    3_41_55_00_71_72_83_21,
			    1,
			    3_82_51_23_05_65_46_41_30_51,
			    1,
			    1,
			    31_86_65_85_78_34_03_11_51_16_74_61,
			    3_31_70_44_06_46_79_88_73_85_96_19_81,
			]

			lowerCamelCase						:Union[str, Any]						  =     [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41]
			for idx, _p in enumerate(_lowerCAmelCase						,			1):
						if n < _p:
									# then we have our last prime to check
									lowerCamelCase						:str						  =     primes[:idx]
									break
			lowerCamelCase						:List[str]						  =     n - 1, 0
			# break up n -1 into a power of 2 (s) and
			# remaining odd component
			# essentially, solve for d * 2 ** s == n - 1
			while d % 2 == 0:
						d //= 2
						s += 1
			for prime in plist:
						lowerCamelCase						:int						  =     False
						for r in range(_lowerCAmelCase):
									lowerCamelCase						:Any						  =     pow(_lowerCAmelCase						,			d * 2**r						,			_lowerCAmelCase)
									# see article for analysis explanation for m
									if (r == 0 and m == 1) or ((m + 1) % n == 0):
												lowerCamelCase						:Optional[Any]						  =     True
												# this loop will not determine compositeness
												break
						if pr:
									continue
						# if pr is False, then the above loop never evaluated to true,
						# and the n MUST be composite
						return False
			return True





def  _lowerCamelCase					(   ):
			assert not miller_rabin(5_61)
			assert miller_rabin(5_63)
			# 2047

			assert not miller_rabin(83_82_01)
			assert miller_rabin(83_82_07)
			# 1_373_653

			assert not miller_rabin(17_31_60_01)
			assert miller_rabin(17_31_60_17)
			# 25_326_001

			assert not miller_rabin(30_78_38_66_41)
			assert miller_rabin(30_78_38_66_53)
			# 3_215_031_751

			assert not miller_rabin(1_71_30_45_57_48_01)
			assert miller_rabin(1_71_30_45_57_48_19)
			# 2_152_302_898_747

			assert not miller_rabin(2_77_97_99_72_83_07)
			assert miller_rabin(2_77_97_99_72_83_27)
			# 3_474_749_660_383

			assert not miller_rabin(1_13_85_00_23_90_94_41)
			assert miller_rabin(1_13_85_00_23_90_95_27)
			# 341_550_071_728_321

			assert not miller_rabin(1_27_50_41_01_88_48_80_43_51)
			assert miller_rabin(1_27_50_41_01_88_48_80_43_91)
			# 3_825_123_056_546_413_051

			assert not miller_rabin(7_96_66_46_44_58_50_77_87_79_18_67)
			assert miller_rabin(7_96_66_46_44_58_50_77_87_79_19_51)
			# 318_665_857_834_031_151_167_461

			assert not miller_rabin(55_28_40_67_74_46_64_78_97_66_03_33)
			assert miller_rabin(55_28_40_67_74_46_64_78_97_66_03_59)
			# 3_317_044_064_679_887_385_961_981
			# upper limit for probabilistic test


if __name__ == "__main__":
			test_miller_rabin()




import numpy
class   _lowerCAmelCase		:







							def __init__(				self     :    Dict	,					__snake_case     :    numpy.ndarray	,					__snake_case     :    numpy.ndarray		):
										lowerCamelCase						:Dict						  =     input_array

										# Random initial weights are assigned where first argument is the
										# number of nodes in previous layer and second argument is the
										# number of nodes in the next layer.

										# Random initial weights are assigned.
										# self.input_array.shape[1] is used to represent number of nodes in input layer.
										# First hidden layer consists of 4 nodes.
										lowerCamelCase						:Dict						  =     numpy.random.rand(
										    self.input_array.shape[1]	,					4		)

										# Random initial values for the first hidden layer.
										# First hidden layer has 4 nodes.
										# Second hidden layer has 3 nodes.
										lowerCamelCase						:Dict						  =     numpy.random.rand(
										    4	,					3		)

										# Random initial values for the second hidden layer.
										# Second hidden layer has 3 nodes.
										# Output layer has 1 node.
										lowerCamelCase						:Any						  =     numpy.random.rand(3	,					1		)

										# Real output values provided.
										lowerCamelCase						:Union[str, Any]						  =     output_array

										# Predicted output values by the neural network.
										# Predicted_output array initially consists of zeroes.
										lowerCamelCase						:List[str]						  =     numpy.zeros(output_array.shape		)







							def 				snake_case  (				self     :    Optional[int]		):
										lowerCamelCase						:Any						  =     sigmoid(
										    numpy.dot(self.input_array	,					self.input_layer_and_first_hidden_layer_weights		)		)

										# layer_between_first_hidden_layer_and_second_hidden_layer is the layer
										# connecting the first hidden set of nodes with the second hidden set of nodes.
										lowerCamelCase						:Any						  =     sigmoid(
										    numpy.dot(
										        self.layer_between_input_and_first_hidden_layer	,					self.first_hidden_layer_and_second_hidden_layer_weights	,					)		)

										# layer_between_second_hidden_layer_and_output is the layer connecting
										# second hidden layer with the output node.
										lowerCamelCase						:Dict						  =     sigmoid(
										    numpy.dot(
										        self.layer_between_first_hidden_layer_and_second_hidden_layer	,					self.second_hidden_layer_and_output_layer_weights	,					)		)

										return self.layer_between_second_hidden_layer_and_output







							def 				snake_case  (				self     :    Any		):
										lowerCamelCase						:Union[str, Any]						  =     numpy.dot(
										    self.layer_between_first_hidden_layer_and_second_hidden_layer.T	,					2
										    * (self.output_array - self.predicted_output)
										    * sigmoid_derivative(self.predicted_output		)	,					)
										lowerCamelCase						:Dict						  =     numpy.dot(
										    self.layer_between_input_and_first_hidden_layer.T	,					numpy.dot(
										        2
										        * (self.output_array - self.predicted_output)
										        * sigmoid_derivative(self.predicted_output		)	,					self.second_hidden_layer_and_output_layer_weights.T	,					)
										    * sigmoid_derivative(
										        self.layer_between_first_hidden_layer_and_second_hidden_layer		)	,					)
										lowerCamelCase						:int						  =     numpy.dot(
										    self.input_array.T	,					numpy.dot(
										        numpy.dot(
										            2
										            * (self.output_array - self.predicted_output)
										            * sigmoid_derivative(self.predicted_output		)	,					self.second_hidden_layer_and_output_layer_weights.T	,					)
										        * sigmoid_derivative(
										            self.layer_between_first_hidden_layer_and_second_hidden_layer		)	,					self.first_hidden_layer_and_second_hidden_layer_weights.T	,					)
										    * sigmoid_derivative(self.layer_between_input_and_first_hidden_layer		)	,					)

										self.input_layer_and_first_hidden_layer_weights += (
										    updated_input_layer_and_first_hidden_layer_weights
										)
										self.first_hidden_layer_and_second_hidden_layer_weights += (
										    updated_first_hidden_layer_and_second_hidden_layer_weights
										)
										self.second_hidden_layer_and_output_layer_weights += (
										    updated_second_hidden_layer_and_output_layer_weights
										)







							def 				snake_case  (				self     :    Dict	,					__snake_case     :    numpy.ndarray	,					__snake_case     :    int	,					__snake_case     :    bool		):
										for iteration in range(1	,					iterations + 1		):
													lowerCamelCase						:Union[str, Any]						  =     self.feedforward()
													self.back_propagation()
													if give_loss:
																lowerCamelCase						:Tuple						  =     numpy.mean(numpy.square(output - self.feedforward()		)		)
																print(F"Iteration {iteration} Loss: {loss}"		)







							def 				snake_case  (				self     :    Optional[int]	,					__snake_case     :    numpy.ndarray		):
										lowerCamelCase						:int						  =     input_arr

										lowerCamelCase						:Union[str, Any]						  =     sigmoid(
										    numpy.dot(self.array	,					self.input_layer_and_first_hidden_layer_weights		)		)

										lowerCamelCase						:Optional[Any]						  =     sigmoid(
										    numpy.dot(
										        self.layer_between_input_and_first_hidden_layer	,					self.first_hidden_layer_and_second_hidden_layer_weights	,					)		)

										lowerCamelCase						:Optional[int]						  =     sigmoid(
										    numpy.dot(
										        self.layer_between_first_hidden_layer_and_second_hidden_layer	,					self.second_hidden_layer_and_output_layer_weights	,					)		)

										return int(self.layer_between_second_hidden_layer_and_output > 0.6		)





def  _lowerCamelCase					(   a_				: numpy.ndarray):
			return 1 / (1 + numpy.exp(-value))





def  _lowerCamelCase					(   a_				: numpy.ndarray):
			return (value) * (1 - (value))





def  _lowerCamelCase					(   ):
			lowerCamelCase						:Optional[Any]						  =     numpy.array(
			    (
			        [0, 0, 0],
			        [0, 0, 1],
			        [0, 1, 0],
			        [0, 1, 1],
			        [1, 0, 0],
			        [1, 0, 1],
			        [1, 1, 0],
			        [1, 1, 1],
			    )						,			dtype=numpy.floataa						,			)

			# True output values for the given input values.
			lowerCamelCase						:int						  =     numpy.array(([0], [1], [1], [0], [1], [0], [0], [1])						,			dtype=numpy.floataa)

			# Calling neural network class.
			lowerCamelCase						:List[Any]						  =     TwoHiddenLayerNeuralNetwork(
			    input_array=a_						,			output_array=a_)

			# Calling training function.
			# Set give_loss to True if you want to see loss in every iteration.
			neural_network.train(output=a_						,			iterations=10						,			give_loss=a_)

			return neural_network.predict(numpy.array(([1, 1, 1])						,			dtype=numpy.floataa))


if __name__ == "__main__":
			example()



