






'''simple docstring'''

from __future__ import annotations






def 						_UpperCAmelCase     (	a		:						int				)      ->      set[int]:





						"""simple docstring"""
						lowercase_   : List[str]   	=      {1}
						lowercase_   : int   	=      [1]
						for _ in range(2    ,      depth + 1				):
												lowercase_   : List[Any]   	=      [*previous_coefficients, 0]
												lowercase_   : Dict   	=      [0, *previous_coefficients]
												lowercase_   : Dict   	=      []
												for x, y in zip(a    ,      a				):
																		coefficients.add(x + y				)
																		previous_coefficients.append(x + y				)
						return coefficients






def 						_UpperCAmelCase     (	a		:						set[int]				)      ->      set[int]:





						"""simple docstring"""
						lowercase_   : Tuple   	=      set()
						for number in unique_coefficients:
												lowercase_   : Optional[int]   	=      2
												lowercase_   : Optional[int]   	=      number
												while divisor**2 <= copy_number:
																		lowercase_   : List[str]   	=      0
																		while copy_number % divisor == 0:
																								copy_number //= divisor
																								multiplicity += 1
																		if multiplicity >= 2:
																								non_squarefrees.add(a				)
																								break
																		divisor += 1

						return unique_coefficients.difference(a				)






def 						_UpperCAmelCase     (	a		:						int = 5_1				)      ->      int:





						"""simple docstring"""
						lowercase_   : int   	=      get_pascal_triangle_unique_coefficients(a				)
						lowercase_   : str   	=      get_squarefrees(a				)
						return sum(a				)


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








'''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     (	)      ->      Optional[Any]:





						"""simple docstring"""
						lowercase_   : List[str]   	=      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=a    ,      default=1    ,      help='Number of TPU cores to use (1 or 8).'				)

						# positional
						parser.add_argument(
						    'training_script'    ,      type=a    ,      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=a				)

						return parser.parse_args()






def 						_UpperCAmelCase     (	)      ->      str:





						"""simple docstring"""
						lowercase_   : Optional[int]   	=      parse_args()

						# Import training_script as a module.
						lowercase_   : str   	=      Path(args.training_script				)
						sys.path.append(str(script_fpath.parent.resolve()				)				)
						lowercase_   : int   	=      script_fpath.stem
						lowercase_   : List[Any]   	=      importlib.import_module(a				)

						# Patch sys.argv
						lowercase_   : List[str]   	=      [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()
