



from collections import defaultdict

def       A_   (						__a  :					str		):

				"""simple docstring"""
				a__					   =		defaultdict(__a		)
				# Creating a dictionary containing count of each word
				for word in sentence.split():
								occurrence[word] += 1
				return occurrence


if __name__ == "__main__":
	for word, count in word_occurrence("""INPUT STRING""").items():
		print(f"""{word}: {count}""")





"""simple docstring"""
import argparse
import json
import re
import string
import sys
from collections import Counter







def     _a					(   _SCREAMING_SNAKE_CASE					)     ->					Any:

							def remove_articles(_SCREAMING_SNAKE_CASE					):
														return re.sub(r"""\b(a|an|the)\b"""					,			""" """					,			_SCREAMING_SNAKE_CASE					)

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

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

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

							return white_space_fix(remove_articles(remove_punc(lower(_SCREAMING_SNAKE_CASE					)					)					)					)







def     _a					(   _SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					)     ->					Optional[int]:
							snake_case_     							=		normalize_answer(_SCREAMING_SNAKE_CASE					).split()
							snake_case_     							=		normalize_answer(_SCREAMING_SNAKE_CASE					).split()
							snake_case_     							=		Counter(_SCREAMING_SNAKE_CASE					) & Counter(_SCREAMING_SNAKE_CASE					)
							snake_case_     							=		sum(common.values()					)
							if num_same == 0:
														return 0
							snake_case_     							=		1.0 * num_same / len(_SCREAMING_SNAKE_CASE					)
							snake_case_     							=		1.0 * num_same / len(_SCREAMING_SNAKE_CASE					)
							snake_case_     							=		(2 * precision * recall) / (precision + recall)
							return fa







def     _a					(   _SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					)     ->					Union[str, Any]:
							return normalize_answer(_SCREAMING_SNAKE_CASE					) == normalize_answer(_SCREAMING_SNAKE_CASE					)







def     _a					(   _SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					)     ->					Optional[int]:
							snake_case_     							=		[]
							for ground_truth in ground_truths:
														snake_case_     							=		metric_fn(_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					)
														scores_for_ground_truths.append(_SCREAMING_SNAKE_CASE					)
							return max(_SCREAMING_SNAKE_CASE					)







def     _a					(   _SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					)     ->					Optional[int]:
							snake_case_     							=		snake_case_     							=		snake_case_     							=		0
							for article in dataset:
														for paragraph in article["paragraphs"]:
																					for qa in paragraph["qas"]:
																												total += 1
																												if qa["id"] not in predictions:
																																			snake_case_     							=		"""Unanswered question """ + qa["""id"""] + """ will receive score 0."""
																																			print(_SCREAMING_SNAKE_CASE					,			file=sys.stderr					)
																																			continue
																												snake_case_     							=		[x["""text"""] for x in qa["""answers"""]]
																												snake_case_     							=		predictions[qa["""id"""]]
																												exact_match += metric_max_over_ground_truths(_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					)
																												fa += metric_max_over_ground_truths(_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					)

							snake_case_     							=		100.0 * exact_match / total
							snake_case_     							=		100.0 * fa / total

							return {"exact_match": exact_match, "f1": fa}


if __name__ == "__main__":
				__SCREAMING_SNAKE_CASE				:     Tuple		=     '1.1'
				__SCREAMING_SNAKE_CASE				:     Union[str, Any]		=     argparse.ArgumentParser(description='Evaluation for SQuAD ' + expected_version)
				parser.add_argument('dataset_file', help='Dataset file')
				parser.add_argument('prediction_file', help='Prediction File')
				__SCREAMING_SNAKE_CASE				:     Union[str, Any]		=     parser.parse_args()
				with open(args.dataset_file) as dataset_file:
								__SCREAMING_SNAKE_CASE				:     Optional[Any]		=     json.load(dataset_file)
								if dataset_json["version"] != expected_version:
												print(
												    'Evaluation expects v-' + expected_version + ', but got dataset with v-' + dataset_json['version'],
												    file=sys.stderr,
												)
								__SCREAMING_SNAKE_CASE				:     str		=     dataset_json['data']
				with open(args.prediction_file) as prediction_file:
								__SCREAMING_SNAKE_CASE				:     int		=     json.load(prediction_file)
				print(json.dumps(evaluate(dataset, predictions)))



