



"""simple docstring"""
from multiprocessing import Lock, Pipe, Process

# lock used to ensure that two processes do not access a pipe at the same time
__SCREAMING_SNAKE_CASE  :						Union[str, Any]    							=      Lock()



def        lowerCAmelCase_(   lowercase_     :							Any						,   lowercase_     :							int						,   lowercase_     :							List[Any]						,   lowercase_     :							Union[str, Any]						,   lowercase_     :							Tuple						,   lowercase_     :							str						,   lowercase_     :							int							)	->       Dict:
				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(lowercase_							)
												process_lock.release()

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

												# take the lower value since you are on the left
												_lowerCamelCase        =				min(lowercase_						,   lowercase_							)
								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(lowercase_							)
												process_lock.release()

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

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



def        lowerCAmelCase_(   lowercase_     :							Union[str, Any]							)	->       Tuple:
				_lowerCamelCase        =				[]
				_lowerCamelCase        =				[]
				# 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
				_lowerCamelCase        =				Pipe()
				_lowerCamelCase        =				Pipe()
				process_array_.append(
				    Process(
				        target=lowercase_						,   args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0])						,   )							)
				_lowerCamelCase        =				temp_rs
				_lowerCamelCase        =				temp_rr

				for i in range(1						,   len(lowercase_							) - 1							):
								_lowerCamelCase        =				Pipe()
								_lowerCamelCase        =				Pipe()
								process_array_.append(
								    Process(
								        target=lowercase_						,   args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i])						,   )							)
								_lowerCamelCase        =				temp_rs
								_lowerCamelCase        =				temp_rr

				process_array_.append(
				    Process(
				        target=lowercase_						,   args=(
				            len(lowercase_							) - 1,
				            arr[len(lowercase_							) - 1],
				            temp_ls,
				            None,
				            temp_lr,
				            None,
				            result_pipe[len(lowercase_							) - 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(lowercase_							)							):
								_lowerCamelCase        =				result_pipe[p][0].recv()
								process_array_[p].join()
				return arr



def        lowerCAmelCase_(   )	->       str:
				_lowerCamelCase        =				list(range(10						,   0						,   -1							)							)
				print('''Initial List'''							)
				print(*lowercase_							)
				_lowerCamelCase        =				odd_even_transposition(lowercase_							)
				print('''Sorted List\n'''							)
				print(*lowercase_							)


if __name__ == "__main__":
			main()





"""simple docstring"""
def        lowerCAmelCase_(   lowercase_     :							str						,   lowercase_     :							str							)	->       bool:
				_lowerCamelCase        =				len(lowercase_							)
				_lowerCamelCase        =				len(lowercase_							)
				_lowerCamelCase        =				[[False for _ in range(m + 1							)] for _ in range(n + 1							)]
				_lowerCamelCase        =				True
				for i in range(lowercase_							):
								for j in range(m + 1							):
												if dp[i][j]:
																if j < m and a[i].upper() == b[j]:
																				_lowerCamelCase        =				True
																if a[i].islower():
																				_lowerCamelCase        =				True
				return dp[n][m]


if __name__ == "__main__":
			import doctest

			doctest.testmod()
