import argparse
import os

import torch

from transformers import (
    XLNetConfig,
    XLNetForQuestionAnswering,
    XLNetForSequenceClassification,
    XLNetLMHeadModel,
    load_tf_weights_in_xlnet,
)
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


lowerCamelCase_    :		Tuple							=	{
    """cola""": 2,
    """mnli""": 3,
    """mrpc""": 2,
    """sst-2""": 2,
    """sts-b""": 1,
    """qqp""": 2,
    """qnli""": 2,
    """rte""": 2,
    """wnli""": 2,
}


logging.set_verbosity_info()
def 							lowerCAmelCase(     __lowerCamelCase				,    __lowerCamelCase				,    __lowerCamelCase				,    __lowerCamelCase=None						):
					# Initialise PyTorch model
					__a		 =       XLNetConfig.from_json_file(__lowerCamelCase						)

					__a		 =       finetuning_task.lower() if finetuning_task is not None else ''
					if finetuning_task in GLUE_TASKS_NUM_LABELS:
										print(f'''Building PyTorch XLNetForSequenceClassification model from configuration: {config}'''						)
										__a		 =       finetuning_task
										__a		 =       GLUE_TASKS_NUM_LABELS[finetuning_task]
										__a		 =       XLNetForSequenceClassification(__lowerCamelCase						)
					elif "squad" in finetuning_task:
										__a		 =       finetuning_task
										__a		 =       XLNetForQuestionAnswering(__lowerCamelCase						)
					else:
										__a		 =       XLNetLMHeadModel(__lowerCamelCase						)

					# Load weights from tf checkpoint
					load_tf_weights_in_xlnet(__lowerCamelCase				,    __lowerCamelCase				,    __lowerCamelCase						)

					# Save pytorch-model
					__a		 =       os.path.join(__lowerCamelCase				,    __lowerCamelCase						)
					__a		 =       os.path.join(__lowerCamelCase				,    __lowerCamelCase						)
					print(f'''Save PyTorch model to {os.path.abspath(__lowerCamelCase						)}'''						)
					torch.save(model.state_dict()				,    __lowerCamelCase						)
					print(f'''Save configuration file to {os.path.abspath(__lowerCamelCase						)}'''						)
					with open(__lowerCamelCase				,    'w'				,    encoding='utf-8'						) as f:
										f.write(config.to_json_string()						)


if __name__ == "__main__":
	lowerCamelCase_    :		int							=	argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
	)
	parser.add_argument(
	    """--xlnet_config_file""",
	    default=None,
	    type=str,
	    required=True,
	    help=(
	        """The config json file corresponding to the pre-trained XLNet model. \n"""
	        """This specifies the model architecture."""
	    ),
	)
	parser.add_argument(
	    """--pytorch_dump_folder_path""",
	    default=None,
	    type=str,
	    required=True,
	    help="""Path to the folder to store the PyTorch model or dataset/vocab.""",
	)
	parser.add_argument(
	    """--finetuning_task""",
	    default=None,
	    type=str,
	    help="""Name of a task on which the XLNet TensorFlow model was fine-tuned""",
	)
	lowerCamelCase_    :		Dict							=	parser.parse_args()
	print(args)

	convert_xlnet_checkpoint_to_pytorch(
	    args.tf_checkpoint_path, args.xlnet_config_file, args.pytorch_dump_folder_path, args.finetuning_task
	)





from math import sqrt
def 							lowerCAmelCase(     __lowerCamelCase						):
					__a		 =       0
					for i in range(1				,    int(sqrt(__lowerCamelCase						) + 1						)						):
										if n % i == 0 and i != sqrt(__lowerCamelCase						):
															total += i + n // i
										elif i == sqrt(__lowerCamelCase						):
															total += i
					return total - n
def 							lowerCAmelCase(     __lowerCamelCase = 1_0000						):
					__a		 =       sum(
					    i
					    for i in range(1				,    __lowerCamelCase						)
					    if sum_of_divisors(sum_of_divisors(__lowerCamelCase						)						) == i and sum_of_divisors(__lowerCamelCase						) != i						)
					return total


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




