





from argparse import ArgumentParser

from ..pipelines import Pipeline, PipelineDataFormat, get_supported_tasks, pipeline
from ..utils import logging
from . import BaseTransformersCLICommand


UpperCamelCase__           =			logging.get_logger(__name__)  # pylint: disable=invalid-name





def      _UpperCamelCase  (a__ :str							):






							"""simple docstring"""





							if not path:
														return "pipe"

							for ext in PipelineDataFormat.SUPPORTED_FORMATS:
														if path.endswith(a__							):
																					return ext

							raise Exception(
							    f"""Unable to determine file format from file extension {path}. """
							    f"""Please provide the format through --format {PipelineDataFormat.SUPPORTED_FORMATS}"""							)





def      _UpperCamelCase  (a__ :Union[str, Any]							):






							"""simple docstring"""





							UpperCamelCase__					  =      pipeline(
							    task=args.task ,      model=args.model if args.model else None ,      config=args.config ,      tokenizer=args.tokenizer ,      device=args.device ,      )
							UpperCamelCase__					  =      try_infer_format_from_ext(args.input							) if args.format == """infer""" else args.format
							UpperCamelCase__					  =      PipelineDataFormat.from_str(
							    format=a__ ,      output_path=args.output ,      input_path=args.input ,      column=args.column if args.column else nlp.default_input_names ,      overwrite=args.overwrite ,      )
							return RunCommand(a__ ,      a__							)

class 							__SCREAMING_SNAKE_CASE       (  _a							):






							def __init__(    self	,			__lowerCAmelCase	,			__lowerCAmelCase	):
														UpperCamelCase__					  =      nlp
														UpperCamelCase__					  =      reader






							@staticmethod
							def 					_lowerCamelCase		(    __lowerCAmelCase	):
														UpperCamelCase__					  =      parser.add_parser("""run"""	,			help="""Run a pipeline through the CLI"""	)
														run_parser.add_argument("""--task"""	,			choices=get_supported_tasks()	,			help="""Task to run"""	)
														run_parser.add_argument("""--input"""	,			type=__lowerCAmelCase	,			help="""Path to the file to use for inference"""	)
														run_parser.add_argument("""--output"""	,			type=__lowerCAmelCase	,			help="""Path to the file that will be used post to write results."""	)
														run_parser.add_argument("""--model"""	,			type=__lowerCAmelCase	,			help="""Name or path to the model to instantiate."""	)
														run_parser.add_argument("""--config"""	,			type=__lowerCAmelCase	,			help="""Name or path to the model's config to instantiate."""	)
														run_parser.add_argument(
														    """--tokenizer"""	,			type=__lowerCAmelCase	,			help="""Name of the tokenizer to use. (default: same as the model name)"""	)
														run_parser.add_argument(
														    """--column"""	,			type=__lowerCAmelCase	,			help="""Name of the column to use as input. (For multi columns input as QA use column1,columns2)"""	,			)
														run_parser.add_argument(
														    """--format"""	,			type=__lowerCAmelCase	,			default="""infer"""	,			choices=PipelineDataFormat.SUPPORTED_FORMATS	,			help="""Input format to read from"""	,			)
														run_parser.add_argument(
														    """--device"""	,			type=__lowerCAmelCase	,			default=-1	,			help="""Indicate the device to run onto, -1 indicates CPU, >= 0 indicates GPU (default: -1)"""	,			)
														run_parser.add_argument("""--overwrite"""	,			action="""store_true"""	,			help="""Allow overwriting the output file."""	)
														run_parser.set_defaults(func=__lowerCAmelCase	)







							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__  ,  UpperCamelCase__					  =      self._nlp, []

														for entry in self._reader:
																					UpperCamelCase__					  =      nlp(**__lowerCAmelCase	) if self._reader.is_multi_columns else nlp(__lowerCAmelCase	)
																					if isinstance(__lowerCAmelCase	,			__lowerCAmelCase	):
																												outputs.append(__lowerCAmelCase	)
																					else:
																												outputs += output

        # Saving data
														if self._nlp.binary_output:
																					UpperCamelCase__					  =      self._reader.save_binary(__lowerCAmelCase	)
																					logger.warning(f"""Current pipeline requires output to be in binary format, saving at {binary_path}"""	)
														else:
																					self._reader.save(__lowerCAmelCase	)











def      _UpperCamelCase  (a__ :int = 1000							):






							"""simple docstring"""





							UpperCamelCase__					  =      2**power
							UpperCamelCase__					  =      0
							while n:
														UpperCamelCase__  ,  UpperCamelCase__					  =      r + n % 10, n // 10
							return r


if __name__ == "__main__":
					print(solution(int(str(input()).strip())))




