





from multiprocessing import Lock, Pipe, Process

# lock used to ensure that two processes do not access a pipe at the same time
lowerCAmelCase_        =							Lock()






def 	lowerCamelCase_		(							_UpperCamelCase					,							_UpperCamelCase					,							_UpperCamelCase					,							_UpperCamelCase					,							_UpperCamelCase					,							_UpperCamelCase					,							_UpperCamelCase					)						->		Any:






				"""simple docstring"""


				global process_lock

				# we perform n swaps since after n swaps we know we are sorted
				# we *could* stop early if we are sorted already, but it takes as long to
				# find out we are sorted as it does to sort the list with this algorithm
				for i in range(0					,							10					):
								if (i + position) % 2 == 0 and r_send is not None:
												# send your value to your right neighbor
												process_lock.acquire()
												r_send[1].send(_UpperCamelCase					)
												process_lock.release()

												# receive your right neighbor's value
												process_lock.acquire()
												snake_case_		:       Optional[Any]           =    rr_cv[0].recv()
												process_lock.release()

												# take the lower value since you are on the left
												snake_case_		:       Union[str, Any]           =    min(_UpperCamelCase					,							_UpperCamelCase					)
								elif (i + position) % 2 != 0 and l_send is not None:
												# send your value to your left neighbor
												process_lock.acquire()
												l_send[1].send(_UpperCamelCase					)
												process_lock.release()

												# receive your left neighbor's value
												process_lock.acquire()
												snake_case_		:       List[Any]           =    lr_cv[0].recv()
												process_lock.release()

												# take the higher value since you are on the right
												snake_case_		:       Optional[int]           =    max(_UpperCamelCase					,							_UpperCamelCase					)
    # after all swaps are performed, send the values back to main
				result_pipe[1].send(_UpperCamelCase					)






def 	lowerCamelCase_		(							_UpperCamelCase					)						->		Any:






				"""simple docstring"""


				snake_case_		:       str           =    []
				snake_case_		:       Any           =    []
				# initialize the list of pipes where the values will be retrieved
				for _ in arr:
								result_pipe.append(Pipe()					)
				# creates the processes
				# the first and last process only have one neighbor so they are made outside
				# of the loop
				snake_case_		:       List[str]           =    Pipe()
				snake_case_		:       Optional[int]           =    Pipe()
				process_array_.append(
				    Process(
				        target=_UpperCamelCase					,							args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0])					,							)					)
				snake_case_		:       Union[str, Any]           =    temp_rs
				snake_case_		:       Tuple           =    temp_rr

				for i in range(1					,							len(_UpperCamelCase					) - 1					):
								snake_case_		:       Optional[Any]           =    Pipe()
								snake_case_		:       Optional[int]           =    Pipe()
								process_array_.append(
								    Process(
								        target=_UpperCamelCase					,							args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i])					,							)					)
								snake_case_		:       Any           =    temp_rs
								snake_case_		:       Optional[Any]           =    temp_rr

				process_array_.append(
				    Process(
				        target=_UpperCamelCase					,							args=(
				            len(_UpperCamelCase					) - 1,
				            arr[len(_UpperCamelCase					) - 1],
				            temp_ls,
				            None,
				            temp_lr,
				            None,
				            result_pipe[len(_UpperCamelCase					) - 1],
				        )					,							)					)

				# start the processes
				for p in process_array_:
								p.start()

				# wait for the processes to end and write their values to the list
				for p in range(0					,							len(_UpperCamelCase					)					):
								snake_case_		:       Optional[int]           =    result_pipe[p][0].recv()
								process_array_[p].join()
				return arr






def 	lowerCamelCase_		(							)						->		Optional[int]:






				"""simple docstring"""


				snake_case_		:       Optional[Any]           =    list(range(10					,							0					,							-1					)					)
				print('''Initial List'''					)
				print(*_UpperCamelCase					)
				snake_case_		:       Dict           =    odd_even_transposition(_UpperCamelCase					)
				print('''Sorted List\n'''					)
				print(*_UpperCamelCase					)


if __name__ == "__main__":
	main()




'''simple docstring'''





def 						UpperCAmelCase__(				_SCREAMING_SNAKE_CASE					: int,_SCREAMING_SNAKE_CASE					: int ):






			"""simple docstring"""




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






def 						UpperCAmelCase__(				):






			"""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))



