'''simple docstring'''

import argparse
import json
import os

from tensorflow.core.protobuf.saved_model_pba import SavedModel


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_copies.py
snake_case_			=     """."""

# Internal TensorFlow ops that can be safely ignored (mostly specific to a saved model)
snake_case_			=     [
    """Assert""",
    """AssignVariableOp""",
    """EmptyTensorList""",
    """MergeV2Checkpoints""",
    """ReadVariableOp""",
    """ResourceGather""",
    """RestoreV2""",
    """SaveV2""",
    """ShardedFilename""",
    """StatefulPartitionedCall""",
    """StaticRegexFullMatch""",
    """VarHandleOp""",
]






def       __lowercase  (_SCREAMING_SNAKE_CASE      :str    ,	_SCREAMING_SNAKE_CASE      :str    ,	_SCREAMING_SNAKE_CASE      :Dict       ):
				SCREAMING_SNAKE_CASE  :						Dict      					= SavedModel()
				SCREAMING_SNAKE_CASE  :						Any      					= []

				with open(os.path.join(_SCREAMING_SNAKE_CASE    ,	'''utils'''    ,	'''tf_ops'''    ,	'''onnx.json'''       )       ) as f:
								SCREAMING_SNAKE_CASE  :						Optional[Any]      					= json.load(_SCREAMING_SNAKE_CASE       )['''opsets''']

				for i in range(1    ,	opset + 1       ):
								onnx_ops.extend(onnx_opsets[str(_SCREAMING_SNAKE_CASE       )]       )

				with open(_SCREAMING_SNAKE_CASE    ,	'''rb'''       ) as f:
								saved_model.ParseFromString(f.read()       )

				SCREAMING_SNAKE_CASE  :						List[Any]      					= set()

				# Iterate over every metagraph in case there is more than one (a saved model can contain multiple graphs)
				for meta_graph in saved_model.meta_graphs:
								# Add operations in the graph definition
								model_op_names.update(node.op for node in meta_graph.graph_def.node       )

								# Go through the functions in the graph definition
								for func in meta_graph.graph_def.library.function:
												# Add operations in each function
												model_op_names.update(node.op for node in func.node_def       )

    # Convert to list, sorted if you want
				SCREAMING_SNAKE_CASE  :						int      					= sorted(_SCREAMING_SNAKE_CASE       )
				SCREAMING_SNAKE_CASE  :						Any      					= []

				for op in model_op_names:
								if op not in onnx_ops and op not in INTERNAL_OPS:
												incompatible_ops.append(_SCREAMING_SNAKE_CASE       )

				if strict and len(_SCREAMING_SNAKE_CASE       ) > 0:
								raise Exception(F'''Found the following incompatible ops for the opset {opset}:\n''' + incompatible_ops       )
				elif len(_SCREAMING_SNAKE_CASE       ) > 0:
								print(F'''Found the following incompatible ops for the opset {opset}:'''       )
								print(*_SCREAMING_SNAKE_CASE    ,	sep='''\n'''       )
				else:
								print(F'''The saved model {saved_model_path} can properly be converted with ONNX.'''       )


if __name__ == "__main__":
	snake_case_			=     argparse.ArgumentParser()
	parser.add_argument("""--saved_model_path""", help="""Path of the saved model to check (the .pb file).""")
	parser.add_argument(
	    """--opset""", default=12, type=int, help="""The ONNX opset against which the model has to be tested."""
	)
	parser.add_argument(
	    """--framework""", choices=["""onnx"""], default="""onnx""", help="""Frameworks against which to test the saved model."""
	)
	parser.add_argument(
	    """--strict""", action="""store_true""", help="""Whether make the checking strict (raise errors) or not (raise warnings)"""
	)
	snake_case_			=     parser.parse_args()

	if args.framework == "onnx":
		onnx_compliancy(args.saved_model_path, args.strict, args.opset)









'''simple docstring'''

def       __lowercase  (_SCREAMING_SNAKE_CASE      :int       ):
				SCREAMING_SNAKE_CASE  :						Tuple      					= 1
				for i in range(1    ,	num + 1       ):
								fact *= i
				return fact






def       __lowercase  (_SCREAMING_SNAKE_CASE      :int       ):
				SCREAMING_SNAKE_CASE  :						List[Any]      					= 0
				while number > 0:
								SCREAMING_SNAKE_CASE  :						List[str]      					= number % 10
								sum_of_digits += last_digit
								SCREAMING_SNAKE_CASE  :						List[str]      					= number // 10  # Removing the last_digit from the given number
				return sum_of_digits






def       __lowercase  (_SCREAMING_SNAKE_CASE      :int = 1_00       ):
				SCREAMING_SNAKE_CASE  :						List[Any]      					= factorial(_SCREAMING_SNAKE_CASE       )
				SCREAMING_SNAKE_CASE  :						List[str]      					= split_and_add(_SCREAMING_SNAKE_CASE       )
				return result


if __name__ == "__main__":
	print(solution(int(input("""Enter the Number: """).strip())))




