


"""simple docstring"""






import argparse
import collections
import json
import os
import re
import string
import sys

import numpy as np


UpperCamelCase__				:Dict			   =	re.compile(R"""\b(a|an|the)\b""", re.UNICODE)

UpperCamelCase__				:Union[str, Any]			   =	None





def 				A_       ( )					->  Optional[Any]:
			_UpperCamelCase					:Optional[int]					     =	argparse.ArgumentParser('''Official evaluation script for SQuAD version 2.0.'''		)
			parser.add_argument('''data_file'''       ,					metavar='''data.json'''       ,					help='''Input data JSON file.'''		)
			parser.add_argument('''pred_file'''       ,					metavar='''pred.json'''       ,					help='''Model predictions.'''		)
			parser.add_argument(
			    '''--out-file'''       ,					'''-o'''       ,					metavar='''eval.json'''       ,					help='''Write accuracy metrics to file (default is stdout).'''		)
			parser.add_argument(
			    '''--na-prob-file'''       ,					'''-n'''       ,					metavar='''na_prob.json'''       ,					help='''Model estimates of probability of no answer.'''		)
			parser.add_argument(
			    '''--na-prob-thresh'''       ,					'''-t'''       ,					type=snake_case__       ,					default=1.0       ,					help='''Predict "" if no-answer probability exceeds this (default = 1.0).'''       ,					)
			parser.add_argument(
			    '''--out-image-dir'''       ,					'''-p'''       ,					metavar='''out_images'''       ,					default=snake_case__       ,					help='''Save precision-recall curves to directory.'''		)
			parser.add_argument('''--verbose'''       ,					'''-v'''       ,					action='''store_true'''		)
			if len(sys.argv		) == 1:
						parser.print_help()
						sys.exit(1		)
			return parser.parse_args()





def 				A_       ( snake_case__		)					->  Dict:
			_UpperCamelCase					:Optional[Any]					     =	{}
			for article in dataset:
						for p in article["paragraphs"]:
									for qa in p["qas"]:
												_UpperCamelCase					:Optional[Any]					     =	bool(qa['''answers''']['''text''']		)
			return qid_to_has_ans





def 				A_       ( snake_case__		)					->  Optional[Any]:

			def remove_articles(snake_case__		):
						return ARTICLES_REGEX.sub(''' '''       ,					snake_case__		)

			def white_space_fix(snake_case__		):
						return " ".join(text.split()		)

			def remove_punc(snake_case__		):
						_UpperCamelCase					:int					     =	set(string.punctuation		)
						return "".join(ch for ch in text if ch not in exclude		)

			def lower(snake_case__		):
						return text.lower()

			return white_space_fix(remove_articles(remove_punc(lower(snake_case__		)		)		)		)





def 				A_       ( snake_case__		)					->  List[str]:
			if not s:
						return []
			return normalize_answer(snake_case__		).split()





def 				A_       ( snake_case__       ,					snake_case__		)					->  Optional[int]:
			return int(normalize_answer(snake_case__		) == normalize_answer(snake_case__		)		)





def 				A_       ( snake_case__       ,					snake_case__		)					->  Optional[int]:
			_UpperCamelCase					:List[Any]					     =	get_tokens(snake_case__		)
			_UpperCamelCase					:Union[str, Any]					     =	get_tokens(snake_case__		)
			_UpperCamelCase					:Dict					     =	collections.Counter(snake_case__		) & collections.Counter(snake_case__		)
			_UpperCamelCase					:str					     =	sum(common.values()		)
			if len(snake_case__		) == 0 or len(snake_case__		) == 0:
						# If either is no-answer, then F1 is 1 if they agree, 0 otherwise
						return int(gold_toks == pred_toks		)
			if num_same == 0:
						return 0
			_UpperCamelCase					:Union[str, Any]					     =	1.0 * num_same / len(snake_case__		)
			_UpperCamelCase					:Dict					     =	1.0 * num_same / len(snake_case__		)
			_UpperCamelCase					:List[Any]					     =	(2 * precision * recall) / (precision + recall)
			return fa





def 				A_       ( snake_case__       ,					snake_case__		)					->  str:
			_UpperCamelCase					:Dict					     =	{}
			_UpperCamelCase					:int					     =	{}
			for article in dataset:
						for p in article["paragraphs"]:
									for qa in p["qas"]:
												_UpperCamelCase					:Any					     =	qa['''id''']
												_UpperCamelCase					:Dict					     =	[t for t in qa['''answers''']['''text'''] if normalize_answer(snake_case__		)]
												if not gold_answers:
															# For unanswerable questions, only correct answer is empty string
															_UpperCamelCase					:Tuple					     =	['''''']
												if qid not in preds:
															print(f"Missing prediction for {qid}"		)
															continue
												_UpperCamelCase					:int					     =	preds[qid]
												# Take max over all gold answers
												_UpperCamelCase					:Union[str, Any]					     =	max(compute_exact(snake_case__       ,					snake_case__		) for a in gold_answers		)
												_UpperCamelCase					:Union[str, Any]					     =	max(compute_fa(snake_case__       ,					snake_case__		) for a in gold_answers		)
			return exact_scores, fa_scores





def 				A_       ( snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__		)					->  Optional[Any]:
			_UpperCamelCase					:Dict					     =	{}
			for qid, s in scores.items():
						_UpperCamelCase					:List[str]					     =	na_probs[qid] > na_prob_thresh
						if pred_na:
									_UpperCamelCase					:Optional[Any]					     =	float(not qid_to_has_ans[qid]		)
						else:
									_UpperCamelCase					:List[str]					     =	s
			return new_scores





def 				A_       ( snake_case__       ,					snake_case__       ,					snake_case__=None		)					->  Union[str, Any]:
			if not qid_list:
						_UpperCamelCase					:Optional[int]					     =	len(snake_case__		)
						return collections.OrderedDict(
						    [
						        ('''exact''', 1_00.0 * sum(exact_scores.values()		) / total),
						        ('''f1''', 1_00.0 * sum(fa_scores.values()		) / total),
						        ('''total''', total),
						    ]		)
			else:
						_UpperCamelCase					:str					     =	len(snake_case__		)
						return collections.OrderedDict(
						    [
						        ('''exact''', 1_00.0 * sum(exact_scores[k] for k in qid_list		) / total),
						        ('''f1''', 1_00.0 * sum(fa_scores[k] for k in qid_list		) / total),
						        ('''total''', total),
						    ]		)





def 				A_       ( snake_case__       ,					snake_case__       ,					snake_case__		)					->  str:
			for k in new_eval:
						_UpperCamelCase					:str					     =	new_eval[k]





def 				A_       ( snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__		)					->  str:
			plt.step(snake_case__       ,					snake_case__       ,					color='''b'''       ,					alpha=0.2       ,					where='''post'''		)
			plt.fill_between(snake_case__       ,					snake_case__       ,					step='''post'''       ,					alpha=0.2       ,					color='''b'''		)
			plt.xlabel('''Recall'''		)
			plt.ylabel('''Precision'''		)
			plt.xlim([0.0, 1.05]		)
			plt.ylim([0.0, 1.05]		)
			plt.title(snake_case__		)
			plt.savefig(snake_case__		)
			plt.clf()





def 				A_       ( snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__=None       ,					snake_case__=None		)					->  Union[str, Any]:
			_UpperCamelCase					:Union[str, Any]					     =	sorted(snake_case__       ,					key=lambda snake_case__		: na_probs[k]		)
			_UpperCamelCase					:List[str]					     =	0.0
			_UpperCamelCase					:Union[str, Any]					     =	1.0
			_UpperCamelCase					:Union[str, Any]					     =	0.0
			_UpperCamelCase					:int					     =	[1.0]
			_UpperCamelCase					:Optional[Any]					     =	[0.0]
			_UpperCamelCase					:Union[str, Any]					     =	0.0
			for i, qid in enumerate(snake_case__		):
						if qid_to_has_ans[qid]:
									true_pos += scores[qid]
						_UpperCamelCase					:Union[str, Any]					     =	true_pos / float(i + 1		)
						_UpperCamelCase					:Optional[int]					     =	true_pos / float(snake_case__		)
						if i == len(snake_case__		) - 1 or na_probs[qid] != na_probs[qid_list[i + 1]]:
									# i.e., if we can put a threshold after this point
									avg_prec += cur_p * (cur_r - recalls[-1])
									precisions.append(snake_case__		)
									recalls.append(snake_case__		)
			if out_image:
						plot_pr_curve(snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__		)
			return {"ap": 1_00.0 * avg_prec}





def 				A_       ( snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__		)					->  List[str]:
			if out_image_dir and not os.path.exists(snake_case__		):
						os.makedirs(snake_case__		)
			_UpperCamelCase					:Dict					     =	sum(1 for v in qid_to_has_ans.values() if v		)
			if num_true_pos == 0:
						return
			_UpperCamelCase					:Any					     =	make_precision_recall_eval(
			    snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					out_image=os.path.join(snake_case__       ,					'''pr_exact.png'''		)       ,					title='''Precision-Recall curve for Exact Match score'''       ,					)
			_UpperCamelCase					:Union[str, Any]					     =	make_precision_recall_eval(
			    snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					out_image=os.path.join(snake_case__       ,					'''pr_f1.png'''		)       ,					title='''Precision-Recall curve for F1 score'''       ,					)
			_UpperCamelCase					:List[Any]					     =	{k: float(snake_case__		) for k, v in qid_to_has_ans.items()}
			_UpperCamelCase					:Tuple					     =	make_precision_recall_eval(
			    snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					out_image=os.path.join(snake_case__       ,					'''pr_oracle.png'''		)       ,					title='''Oracle Precision-Recall curve (binary task of HasAns vs. NoAns)'''       ,					)
			merge_eval(snake_case__       ,					snake_case__       ,					'''pr_exact'''		)
			merge_eval(snake_case__       ,					snake_case__       ,					'''pr_f1'''		)
			merge_eval(snake_case__       ,					snake_case__       ,					'''pr_oracle'''		)





def 				A_       ( snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__		)					->  Tuple:
			if not qid_list:
						return
			_UpperCamelCase					:Tuple					     =	[na_probs[k] for k in qid_list]
			_UpperCamelCase					:int					     =	np.ones_like(snake_case__		) / float(len(snake_case__		)		)
			plt.hist(snake_case__       ,					weights=snake_case__       ,					bins=20       ,					range=(0.0, 1.0)		)
			plt.xlabel('''Model probability of no-answer'''		)
			plt.ylabel('''Proportion of dataset'''		)
			plt.title(f"Histogram of no-answer probability: {name}"		)
			plt.savefig(os.path.join(snake_case__       ,					f"na_prob_hist_{name}.png"		)		)
			plt.clf()





def 				A_       ( snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__		)					->  int:
			_UpperCamelCase					:Tuple					     =	sum(1 for k in qid_to_has_ans if not qid_to_has_ans[k]		)
			_UpperCamelCase					:Union[str, Any]					     =	num_no_ans
			_UpperCamelCase					:Optional[int]					     =	cur_score
			_UpperCamelCase					:Dict					     =	0.0
			_UpperCamelCase					:str					     =	sorted(snake_case__       ,					key=lambda snake_case__		: na_probs[k]		)
			for i, qid in enumerate(snake_case__		):
						if qid not in scores:
									continue
						if qid_to_has_ans[qid]:
									_UpperCamelCase					:Union[str, Any]					     =	scores[qid]
						else:
									if preds[qid]:
												_UpperCamelCase					:Union[str, Any]					     =	-1
									else:
												_UpperCamelCase					:Any					     =	0
						cur_score += diff
						if cur_score > best_score:
									_UpperCamelCase					:str					     =	cur_score
									_UpperCamelCase					:Tuple					     =	na_probs[qid]
			return 1_00.0 * best_score / len(snake_case__		), best_thresh





def 				A_       ( snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__		)					->  Optional[int]:
			_UpperCamelCase     ,      _UpperCamelCase					:List[str]					     =	find_best_thresh(snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__		)
			_UpperCamelCase     ,      _UpperCamelCase					:int					     =	find_best_thresh(snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__		)
			_UpperCamelCase					:int					     =	best_exact
			_UpperCamelCase					:Union[str, Any]					     =	exact_thresh
			_UpperCamelCase					:Any					     =	best_fa
			_UpperCamelCase					:str					     =	fa_thresh





def 				A_       ( )					->  List[Any]:
			with open(OPTS.data_file		) as f:
						_UpperCamelCase					:List[Any]					     =	json.load(snake_case__		)
						_UpperCamelCase					:Optional[int]					     =	dataset_json['''data''']
			with open(OPTS.pred_file		) as f:
						_UpperCamelCase					:List[str]					     =	json.load(snake_case__		)
			if OPTS.na_prob_file:
						with open(OPTS.na_prob_file		) as f:
									_UpperCamelCase					:str					     =	json.load(snake_case__		)
			else:
						_UpperCamelCase					:str					     =	{k: 0.0 for k in preds}
			_UpperCamelCase					:Any					     =	make_qid_to_has_ans(snake_case__		)  # maps qid to True/False
			_UpperCamelCase					:List[Any]					     =	[k for k, v in qid_to_has_ans.items() if v]
			_UpperCamelCase					:List[Any]					     =	[k for k, v in qid_to_has_ans.items() if not v]
			_UpperCamelCase     ,      _UpperCamelCase					:List[Any]					     =	get_raw_scores(snake_case__       ,					snake_case__		)
			_UpperCamelCase					:str					     =	apply_no_ans_threshold(snake_case__       ,					snake_case__       ,					snake_case__       ,					OPTS.na_prob_thresh		)
			_UpperCamelCase					:str					     =	apply_no_ans_threshold(snake_case__       ,					snake_case__       ,					snake_case__       ,					OPTS.na_prob_thresh		)
			_UpperCamelCase					:Optional[int]					     =	make_eval_dict(snake_case__       ,					snake_case__		)
			if has_ans_qids:
						_UpperCamelCase					:str					     =	make_eval_dict(snake_case__       ,					snake_case__       ,					qid_list=snake_case__		)
						merge_eval(snake_case__       ,					snake_case__       ,					'''HasAns'''		)
			if no_ans_qids:
						_UpperCamelCase					:Optional[int]					     =	make_eval_dict(snake_case__       ,					snake_case__       ,					qid_list=snake_case__		)
						merge_eval(snake_case__       ,					snake_case__       ,					'''NoAns'''		)
			if OPTS.na_prob_file:
						find_all_best_thresh(snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__		)
			if OPTS.na_prob_file and OPTS.out_image_dir:
						run_precision_recall_analysis(snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					OPTS.out_image_dir		)
						histogram_na_prob(snake_case__       ,					snake_case__       ,					OPTS.out_image_dir       ,					'''hasAns'''		)
						histogram_na_prob(snake_case__       ,					snake_case__       ,					OPTS.out_image_dir       ,					'''noAns'''		)
			if OPTS.out_file:
						with open(OPTS.out_file       ,					'''w'''		) as f:
									json.dump(snake_case__       ,					snake_case__		)
			else:
						print(json.dumps(snake_case__       ,					indent=2		)		)


if __name__ == "__main__":
					UpperCamelCase__				:List[Any]			   =	parse_args()
					if OPTS.out_image_dir:
										import matplotlib

										matplotlib.use("""Agg""")
										import matplotlib.pyplot as plt
					main()





"""simple docstring"""






def 				A_       ( snake_case__		)					->  int:
			_UpperCamelCase					:Dict					     =	1
			for i in range(1       ,					num + 1		):
						fact *= i
			return fact





def 				A_       ( snake_case__		)					->  int:
			_UpperCamelCase					:Dict					     =	0
			while number > 0:
						_UpperCamelCase					:Tuple					     =	number % 10
						sum_of_digits += last_digit
						_UpperCamelCase					:str					     =	number // 10  # Removing the last_digit from the given number
			return sum_of_digits





def 				A_       ( snake_case__ = 1_00		)					->  int:
			_UpperCamelCase					:int					     =	factorial(snake_case__		)
			_UpperCamelCase					:Dict					     =	split_and_add(snake_case__		)
			return result


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

