





'''simple docstring'''



import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)

class      A_			(	unittest.TestCase	):

			'''simple docstring'''





			def    a						(       self ):
								_UpperCamelCase									= Vector([1, 2, 3] )
								self.assertEqual(x.component(0 )      ,  1 )
								self.assertEqual(x.component(2 )      ,  3 )
								_UpperCamelCase									= Vector()




			def    a						(       self ):
								_UpperCamelCase									= Vector([0, 0, 0, 0, 0, 1] )
								self.assertEqual(str(UpperCAmelCase__ )      ,  "(0,0,0,0,0,1)" )




			def    a						(       self ):
								_UpperCamelCase									= Vector([1, 2, 3, 4] )
								self.assertEqual(len(UpperCAmelCase__ )      ,  4 )




			def    a						(       self ):
								_UpperCamelCase									= Vector([1, 2] )
								_UpperCamelCase									= Vector([1, 2, 3, 4, 5] )
								_UpperCamelCase									= Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0] )
								_UpperCamelCase									= Vector([1, -1, 1, -1, 2, -3, 4, -5] )
								self.assertAlmostEqual(x.euclidean_length()      ,  2.236      ,  3 )
								self.assertAlmostEqual(y.euclidean_length()      ,  7.416      ,  3 )
								self.assertEqual(z.euclidean_length()      ,  0 )
								self.assertAlmostEqual(w.euclidean_length()      ,  7.616      ,  3 )




			def    a						(       self ):
								_UpperCamelCase									= Vector([1, 2, 3] )
								_UpperCamelCase									= Vector([1, 1, 1] )
								self.assertEqual((x + y).component(0 )      ,  2 )
								self.assertEqual((x + y).component(1 )      ,  3 )
								self.assertEqual((x + y).component(2 )      ,  4 )




			def    a						(       self ):
								_UpperCamelCase									= Vector([1, 2, 3] )
								_UpperCamelCase									= Vector([1, 1, 1] )
								self.assertEqual((x - y).component(0 )      ,  0 )
								self.assertEqual((x - y).component(1 )      ,  1 )
								self.assertEqual((x - y).component(2 )      ,  2 )




			def    a						(       self ):
								_UpperCamelCase									= Vector([1, 2, 3] )
								_UpperCamelCase									= Vector([2, -1, 4] )  # for test of dot product
								_UpperCamelCase									= Vector([1, -2, -1] )
								self.assertEqual(str(x * 3.0 )      ,  "(3.0,6.0,9.0)" )
								self.assertEqual((a * b)      ,  0 )




			def    a						(       self ):
								self.assertEqual(str(zero_vector(10 ) ).count("0" )      ,  10 )




			def    a						(       self ):
								self.assertEqual(str(unit_basis_vector(3      ,  1 ) )      ,  "(0,1,0)" )




			def    a						(       self ):
								_UpperCamelCase									= Vector([1, 2, 3] )
								_UpperCamelCase									= Vector([1, 0, 1] )
								self.assertEqual(str(axpy(2      ,  UpperCAmelCase__      ,  UpperCAmelCase__ ) )      ,  "(3,4,7)" )




			def    a						(       self ):
								_UpperCamelCase									= Vector([1, 0, 0, 0, 0, 0] )
								_UpperCamelCase									= x.copy()
								self.assertEqual(str(UpperCAmelCase__ )      ,  str(UpperCAmelCase__ ) )




			def    a						(       self ):
								_UpperCamelCase									= Vector([1, 0, 0] )
								x.change_component(0      ,  0 )
								x.change_component(1      ,  1 )
								self.assertEqual(str(UpperCAmelCase__ )      ,  "(0,1,0)" )




			def    a						(       self ):
								_UpperCamelCase									= Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,  3      ,  3 )
								self.assertEqual("|1,2,3|\n|2,4,5|\n|6,7,8|\n"      ,  str(UpperCAmelCase__ ) )




			def    a						(       self ):
								_UpperCamelCase									= Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,  3      ,  3 )
								_UpperCamelCase									= [[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
								for x in range(a.height() ):
													for y in range(a.width() ):
																		self.assertEqual(minors[x][y]      ,  a.minor(UpperCAmelCase__      ,  UpperCAmelCase__ ) )




			def    a						(       self ):
								_UpperCamelCase									= Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,  3      ,  3 )
								_UpperCamelCase									= [[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
								for x in range(a.height() ):
													for y in range(a.width() ):
																		self.assertEqual(cofactors[x][y]      ,  a.cofactor(UpperCAmelCase__      ,  UpperCAmelCase__ ) )




			def    a						(       self ):
								_UpperCamelCase									= Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,  3      ,  3 )
								self.assertEqual(-5      ,  a.determinant() )




			def    a						(       self ):
								_UpperCamelCase									= Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]      ,  3      ,  3 )
								_UpperCamelCase									= Vector([1, 2, 3] )
								self.assertEqual("(14,32,50)"      ,  str(a * x ) )
								self.assertEqual("|2,4,6|\n|8,10,12|\n|14,16,18|\n"      ,  str(a * 2 ) )




			def    a						(       self ):
								_UpperCamelCase									= Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,  3      ,  3 )
								a.change_component(0      ,  2      ,  5 )
								self.assertEqual("|1,2,5|\n|2,4,5|\n|6,7,8|\n"      ,  str(UpperCAmelCase__ ) )




			def    a						(       self ):
								_UpperCamelCase									= Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,  3      ,  3 )
								self.assertEqual(7      ,  a.component(2      ,  1 )      ,  0.01 )




			def    a						(       self ):
								_UpperCamelCase									= Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,  3      ,  3 )
								_UpperCamelCase									= Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]      ,  3      ,  3 )
								self.assertEqual("|2,4,10|\n|4,8,10|\n|12,14,18|\n"      ,  str(a + b ) )




			def    a						(       self ):
								_UpperCamelCase									= Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,  3      ,  3 )
								_UpperCamelCase									= Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]      ,  3      ,  3 )
								self.assertEqual("|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"      ,  str(a - b ) )




			def    a						(       self ):
								self.assertEqual(
								    "|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n"      ,  str(square_zero_matrix(5 ) )      ,  )


if __name__ == "__main__":
			unittest.main()









def SCREAMING_SNAKE_CASE							(			lowercase_					,							lowercase_		)  ->			int:



       """simple docstring"""

       return int((input_a, input_a).count(1		) != 0		)







def SCREAMING_SNAKE_CASE							(			)  ->			None:



       """simple docstring"""

       assert or_gate(0					,							0		) == 0
       assert or_gate(0					,							1		) == 1
       assert or_gate(1					,							0		) == 1
       assert or_gate(1					,							1		) == 1


if __name__ == "__main__":
  print(or_gate(0, 1))
  print(or_gate(1, 0))
  print(or_gate(0, 0))
  print(or_gate(1, 1))


