"""simple docstring"""


import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp

def 						UpperCamelCase				(	):
    __a			      =						ArgumentParser(
        description=(
            """PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes"""
        )						)

    # Optional arguments for the launch helper
    parser.add_argument("""--num_cores"""				, type=_lowerCAmelCase				, default=1				, help="""Number of TPU cores to use (1 or 8)."""						)

    # positional
    parser.add_argument(
        """training_script"""				, type=_lowerCAmelCase				, help=(
            """The full path to the single TPU training """
            """program/script to be launched in parallel, """
            """followed by all the arguments for the """
            """training script"""
        )				, )

    # rest from the training program
    parser.add_argument("""training_script_args"""				, nargs=_lowerCAmelCase						)

    return parser.parse_args()

def 						UpperCamelCase				(	):
    __a			      =						parse_args()

    # Import training_script as a module.
    __a			      =						Path(args.training_script						)
    sys.path.append(str(script_fpath.parent.resolve()						)						)
    __a			      =						script_fpath.stem
    __a			      =						importlib.import_module(_lowerCAmelCase						)

    # Patch sys.argv
    __a			      =						[args.training_script] + args.training_script_args + ["""--tpu_num_cores""", str(args.num_cores						)]

    xmp.spawn(mod._mp_fn				, args=()				, nprocs=args.num_cores						)


if __name__ == "__main__":
 main()

"""simple docstring"""


def 						UpperCamelCase				(	_lowerCAmelCase   :							Dict				, _lowerCAmelCase   :							Tuple						):
    __a			      =						len(_lowerCAmelCase						)
    # Create a stack and push index of fist element to it
    __a			      =						[]
    st.append(0						)

    # Span value of first element is always 1
    __a			      =						1

    # Calculate span values for rest of the elements
    for i in range(1				, _lowerCAmelCase						):
        # Pop elements from stack while stack is not
        # empty and top of stack is smaller than price[i]
        while len(_lowerCAmelCase						) > 0 and price[st[0]] <= price[i]:
            st.pop()

        # If stack becomes empty, then price[i] is greater
        # than all elements on left of it, i.e. price[0],
        # price[1], ..price[i-1]. Else the price[i]  is
        # greater than elements after top of stack
        __a			      =						i + 1 if len(_lowerCAmelCase						) <= 0 else (i - st[0])

        # Push this element to stack
        st.append(_lowerCAmelCase						)

def 						UpperCamelCase				(	_lowerCAmelCase   :							Dict				, _lowerCAmelCase   :							Optional[Any]						):
    for i in range(0				, _lowerCAmelCase						):
        print(arr[i]				, end=""" """						)


# Driver program to test above function
__A       			=      [10, 4, 5, 90, 1_20, 80]
__A       			=      [0 for i in range(len(price) + 1)]

# Fill the span values in array S[]
calculation_span(price, S)






print_array(S, len(price))
