

from math import factorial

UpperCamelCase__  :      List[str]			=    {str(d): factorial(d) for d in range(10)}


def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		int       ):





    """simple docstring"""


    return sum(DIGIT_FACTORIAL[d] for d in str(_SCREAMING_SNAKE_CASE       )       )


def 					_UpperCAmelCase       (  ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						7 * factorial(9       ) + 1
    return sum(i for i in range(3 ,   _SCREAMING_SNAKE_CASE       ) if sum_of_digit_factorial(_SCREAMING_SNAKE_CASE       ) == i       )


if __name__ == "__main__":
   print(F'{solution() = }')





from multiprocessing import Lock, Pipe, Process

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


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

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

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

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

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


def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		Union[str, Any]       ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						[]
    SCREAMING_SNAKE_CASE_									=						[]
    # 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
    SCREAMING_SNAKE_CASE_									=						Pipe()
    SCREAMING_SNAKE_CASE_									=						Pipe()
    process_array_.append(
        Process(
            target=_SCREAMING_SNAKE_CASE ,   args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0]) ,   )       )
    SCREAMING_SNAKE_CASE_									=						temp_rs
    SCREAMING_SNAKE_CASE_									=						temp_rr

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

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


def 					_UpperCAmelCase       (  ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						list(range(10 ,   0 ,   -1       )       )
    print('Initial List'       )
    print(*_SCREAMING_SNAKE_CASE       )
    SCREAMING_SNAKE_CASE_									=						odd_even_transposition(_SCREAMING_SNAKE_CASE       )
    print('Sorted List\n'       )
    print(*_SCREAMING_SNAKE_CASE       )


if __name__ == "__main__":
       main()


