



'''simple docstring'''

import os

import jsonlines
import numpy as np
from tqdm import tqdm


UpperCAmelCase     		=   2048
UpperCAmelCase     		=   4096
UpperCAmelCase     		=   42
UpperCAmelCase     		=   os.environ.pop('PROCESS_TRAIN', 'false')
UpperCAmelCase     		=   {'null': 0, 'short': 1, 'long': 2, 'yes': 3, 'no': 4}






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						str							)      ->						Union[str, Any]:







	"""simple docstring"""





	def choose_first(_SCREAMING_SNAKE_CASE					:						str							,		_SCREAMING_SNAKE_CASE					:						List[Any]=False							):
		assert isinstance(a__							,		a__							)
		if len(a__							) == 1:
			lowerCAmelCase   =     answer[0]
			return {k: [answer[k]] for k in answer} if is_long_answer else answer
		for a in answer:
			if is_long_answer:
				lowerCAmelCase   =     {k: [a[k]] for k in a}
			if len(a["""start_token"""]							) > 0:
				break
		return a

	lowerCAmelCase   =     {"""id""": example["""id"""]}
	lowerCAmelCase   =     example["""annotations"""]
	lowerCAmelCase   =     annotation["""yes_no_answer"""]
	if 0 in yes_no_answer or 1 in yes_no_answer:
		lowerCAmelCase   =     ["""yes"""] if 1 in yes_no_answer else ["""no"""]
		lowerCAmelCase   =     lowerCAmelCase   =     []
		lowerCAmelCase   =     lowerCAmelCase   =     []
		lowerCAmelCase   =     ["""<cls>"""]
	else:
		lowerCAmelCase   =     ["""short"""]
		lowerCAmelCase   =     choose_first(annotation["""short_answers"""]							)
		if len(out["""start_token"""]							) == 0:
			# answer will be long if short is not available
			lowerCAmelCase   =     ["""long"""]
			lowerCAmelCase   =     choose_first(annotation["""long_answer"""]							,		is_long_answer=a__							)
			lowerCAmelCase   =     []
		answer.update(a__							)

	# disregard some samples
	if len(answer["""start_token"""]							) > 1 or answer["start_token"] == answer["end_token"]:
		lowerCAmelCase   =     True
	else:
		lowerCAmelCase   =     False

	lowerCAmelCase   =     ["""start_token""", """end_token""", """start_byte""", """end_byte""", """text"""]
	if not all(isinstance(answer[k]							,		a__							) for k in cols							):
		raise ValueError("""Issue in ID"""							,		example["""id"""]							)

	return answer






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						Dict							,		_SCREAMING_SNAKE_CASE					:						Union[str, Any]=False							)      ->						Tuple:







	"""simple docstring"""
	lowerCAmelCase   =     _get_single_answer(a__							)
	# bytes are of no use
	del answer["start_byte"]
	del answer["end_byte"]

	# handle yes_no answers explicitly
	if answer["category"][0] in ["yes", "no"]:  # category is list with one element
		lowerCAmelCase   =     example["""document"""]["""tokens"""]
		lowerCAmelCase   =     []
		for i in range(len(doc["""token"""]							)							):
			if not doc["is_html"][i]:
				context.append(doc["""token"""][i]							)
		return {
		    "context": " ".join(a__							),
		    "answer": {
		        "start_token": -100,  # ignore index in cross-entropy
		        "end_token": -100,  # ignore index in cross-entropy
		        "category": answer["category"],
		        "span": answer["category"],  # extra
		    },
		}

	# later, help in removing all no answers
	if answer["start_token"] == [-1]:
		return {
		    "context": "None",
		    "answer": {
		        "start_token": -1,
		        "end_token": -1,
		        "category": "null",
		        "span": "None",  # extra
		    },
		}

	# handling normal samples

	lowerCAmelCase   =     ["""start_token""", """end_token"""]
	answer.update({k: answer[k][0] if len(answer[k]							) > 0 else answer[k] for k in cols}							)  # e.g. [10] == 10

	lowerCAmelCase   =     example["""document"""]["""tokens"""]
	lowerCAmelCase   =     answer["""start_token"""]
	lowerCAmelCase   =     answer["""end_token"""]

	lowerCAmelCase   =     []
	for i in range(len(doc["""token"""]							)							):
		if not doc["is_html"][i]:
			context.append(doc["""token"""][i]							)
		else:
			if answer["start_token"] > i:
				start_token -= 1
			if answer["end_token"] > i:
				end_token -= 1
	lowerCAmelCase   =     """ """.join(context[start_token:end_token]							)

	# checking above code
	if assertion:
		lowerCAmelCase   =     doc["""is_html"""][answer["""start_token"""] : answer["""end_token"""]]
		lowerCAmelCase   =     doc["""token"""][answer["""start_token"""] : answer["""end_token"""]]
		lowerCAmelCase   =     """ """.join([old[i] for i in range(len(a__							)							) if not is_html[i]]							)
		if new != old:
			print("""ID:"""							,		example["""id"""]							)
			print("""New:"""							,		a__							,		end="""\n"""							)
			print("""Old:"""							,		a__							,		end="""\n\n"""							)

	return {
	    "context": " ".join(a__							),
	    "answer": {
	        "start_token": start_token,
	        "end_token": end_token - 1,  # this makes it inclusive
	        "category": answer["category"],  # either long or short
	        "span": new,  # extra
	    },
	}






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						Optional[int]							,		_SCREAMING_SNAKE_CASE					:						Optional[Any]							,		_SCREAMING_SNAKE_CASE					:						Union[str, Any]=2_048							,		_SCREAMING_SNAKE_CASE					:						Optional[int]=4_096							,		_SCREAMING_SNAKE_CASE					:						Optional[Any]=True							)      ->						int:







	"""simple docstring"""
	lowerCAmelCase   =     get_context_and_ans(a__							,		assertion=a__							)
	lowerCAmelCase   =     out["""answer"""]

	# later, removing these samples
	if answer["start_token"] == -1:
		return {
		    "example_id": example["id"],
		    "input_ids": [[-1]],
		    "labels": {
		        "start_token": [-1],
		        "end_token": [-1],
		        "category": ["null"],
		    },
		}

	lowerCAmelCase   =     tokenizer(example["""question"""]["""text"""]							,		out["""context"""]							).input_ids
	lowerCAmelCase   =     input_ids.index(tokenizer.sep_token_id							) + 1

	# return yes/no
	if answer["category"][0] in ["yes", "no"]:  # category is list with one element
		lowerCAmelCase   =     []
		lowerCAmelCase   =     []
		lowerCAmelCase   =     input_ids[:q_len]
		lowerCAmelCase   =     range(a__							,		len(a__							)							,		max_length - doc_stride							)
		for i in doc_start_indices:
			lowerCAmelCase   =     i + max_length - q_len
			lowerCAmelCase   =     input_ids[i:end_index]
			inputs.append(q_indices + slice							)
			category.append(answer["""category"""][0]							)
			if slice[-1] == tokenizer.sep_token_id:
				break

		return {
		    "example_id": example["id"],
		    "input_ids": inputs,
		    "labels": {
		        "start_token": [-100] * len(a__							),
		        "end_token": [-100] * len(a__							),
		        "category": category,
		    },
		}

	lowerCAmelCase   =     out["""context"""].split()
	lowerCAmelCase   =     splitted_context[answer["""end_token"""]]
	lowerCAmelCase   =     len(
	    tokenizer(
	        """ """.join(splitted_context[: answer["""start_token"""]]							)							,		add_special_tokens=a__							,		).input_ids							)
	lowerCAmelCase   =     len(
	    tokenizer(""" """.join(splitted_context[: answer["""end_token"""]]							)							,		add_special_tokens=a__							).input_ids							)

	answer["start_token"] += q_len
	answer["end_token"] += q_len

	# fixing end token
	lowerCAmelCase   =     len(tokenizer(a__							,		add_special_tokens=a__							).input_ids							)
	if num_sub_tokens > 1:
		answer["end_token"] += num_sub_tokens - 1

	lowerCAmelCase   =     input_ids[answer["""start_token"""] : answer["""end_token"""] + 1]  # right & left are inclusive
	lowerCAmelCase   =     answer["""start_token"""]
	lowerCAmelCase   =     answer["""end_token"""]

	if assertion:
		lowerCAmelCase   =     tokenizer.decode(a__							)
		if answer["span"] != new:
			print("""ISSUE IN TOKENIZATION"""							)
			print("""OLD:"""							,		answer["""span"""]							)
			print("""NEW:"""							,		a__							,		end="""\n\n"""							)

	if len(a__							) <= max_length:
		return {
		    "example_id": example["id"],
		    "input_ids": [input_ids],
		    "labels": {
		        "start_token": [answer["start_token"]],
		        "end_token": [answer["end_token"]],
		        "category": answer["category"],
		    },
		}

	lowerCAmelCase   =     input_ids[:q_len]
	lowerCAmelCase   =     range(a__							,		len(a__							)							,		max_length - doc_stride							)

	lowerCAmelCase   =     []
	lowerCAmelCase   =     []
	lowerCAmelCase   =     []
	lowerCAmelCase   =     []  # null, yes, no, long, short
	for i in doc_start_indices:
		lowerCAmelCase   =     i + max_length - q_len
		lowerCAmelCase   =     input_ids[i:end_index]
		inputs.append(q_indices + slice							)
		assert len(inputs[-1]							) <= max_length, "Issue in truncating length"

		if start_token >= i and end_token <= end_index - 1:
			lowerCAmelCase   =     start_token - i + q_len
			lowerCAmelCase   =     end_token - i + q_len
			answers_category.append(answer["""category"""][0]							)  # ["short"] -> "short"
		else:
			lowerCAmelCase   =     -100
			lowerCAmelCase   =     -100
			answers_category.append("""null"""							)
		lowerCAmelCase   =     inputs[-1][start_token : end_token + 1]

		answers_start_token.append(a__							)
		answers_end_token.append(a__							)
		if assertion:
			if new != old and new != [tokenizer.cls_token_id]:
				print("""ISSUE in strided for ID:"""							,		example["""id"""]							)
				print("""New:"""							,		tokenizer.decode(a__							)							)
				print("""Old:"""							,		tokenizer.decode(a__							)							,		end="""\n\n"""							)
		if slice[-1] == tokenizer.sep_token_id:
			break

	return {
	    "example_id": example["id"],
	    "input_ids": inputs,
	    "labels": {
	        "start_token": answers_start_token,
	        "end_token": answers_end_token,
	        "category": answers_category,
	    },
	}






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						Optional[Any]							,		_SCREAMING_SNAKE_CASE					:						Tuple							,		_SCREAMING_SNAKE_CASE					:						Optional[Any]=2_048							,		_SCREAMING_SNAKE_CASE					:						Tuple=4_096							,		_SCREAMING_SNAKE_CASE					:						Optional[Any]=False							)      ->						Tuple:







	"""simple docstring"""
	lowerCAmelCase   =     get_strided_contexts_and_ans(
	    a__							,		a__							,		doc_stride=a__							,		max_length=a__							,		assertion=a__							,		)

	return example






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						Optional[int]							,		_SCREAMING_SNAKE_CASE					:						Optional[int]							)      ->						Optional[Any]:







	"""simple docstring"""





	with jsonlines.open(a__							,		"""a"""							) as writer:
		for example in tqdm(a__							,		total=len(a__							)							,		desc="""Saving samples ... """							):
			lowerCAmelCase   =     example["""labels"""]
			for ids, start, end, cat in zip(
			    example["""input_ids"""]							,		labels["""start_token"""]							,		labels["""end_token"""]							,		labels["""category"""]							,		):
				if start == -1 and end == -1:
					continue  # leave waste samples with no answer
				if cat == "null" and np.random.rand() < 0.6:
					continue  # removing 50 % samples
				writer.write(
				    {
				        """input_ids""": ids,
				        """start_token""": start,
				        """end_token""": end,
				        """category""": CATEGORY_MAPPING[cat],
				    }							)


if __name__ == "__main__":
				from datasets import load_dataset

				from transformers import BigBirdTokenizer

				UpperCAmelCase     		=   load_dataset('natural_questions')
				UpperCAmelCase     		=   BigBirdTokenizer.from_pretrained('google/bigbird-roberta-base')

				UpperCAmelCase     		=   data['train' if PROCESS_TRAIN == 'true' else 'validation']

				UpperCAmelCase     		=   {
				    'tokenizer': tokenizer,
				    'doc_stride': DOC_STRIDE,
				    'max_length': MAX_LENGTH,
				    'assertion': False,
				}
				UpperCAmelCase     		=   data.map(prepare_inputs, fn_kwargs=fn_kwargs)
				UpperCAmelCase     		=   data.remove_columns(['annotations', 'document', 'id', 'question'])
				print(data)

				np.random.seed(SEED)
				UpperCAmelCase     		=   'nq-training.jsonl' if PROCESS_TRAIN == 'true' else 'nq-validation.jsonl'
				save_to_disk(data, file_name=cache_file_name)




'''simple docstring'''

from __future__ import annotations






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						int | str							)      ->						bool:







	"""simple docstring"""
	lowerCAmelCase   =     str(_SCREAMING_SNAKE_CASE							)
	return n == n[::-1]






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						int = 1_000_000							)      ->						Dict:







	"""simple docstring"""
	lowerCAmelCase   =     0

	for i in range(1							,		_SCREAMING_SNAKE_CASE							):
		if is_palindrome(_SCREAMING_SNAKE_CASE							) and is_palindrome(bin(_SCREAMING_SNAKE_CASE							).split("""b"""							)[1]							):
			total += i
	return total


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