code: 
  
  import argparse
  
  import torch
  from torch import nn
  
  from transformers import PLBartConfig, PLBartForConditionalGeneration, PLBartForSequenceClassification
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  Tuple		       =   [
  	    "encoder.version",
  	    "decoder.version",
  	    "model.encoder.version",
  	    "model.decoder.version",
  	    "_float_tensor",
  	    "decoder.output_projection.weight",
  	]
  	for k in ignore_keys:
  		state_dict.pop(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__       ,	UpperCAmelCase__:  Optional[int]		       =   emb.weight.shape
  	UpperCAmelCase__:  List[str]		       =   nn.Linear(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,bias=SCREAMING_SNAKE_CASE			)
  	UpperCAmelCase__:  Union[str, Any]		       =   emb.weight.data
  	return lin_layer
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE="uclanlp/plbart-base"  ,SCREAMING_SNAKE_CASE=False  ,SCREAMING_SNAKE_CASE=False			):
  	UpperCAmelCase__:  List[str]		       =   torch.load(SCREAMING_SNAKE_CASE  ,map_location="cpu"			)["model"]
  	remove_ignore_keys_(SCREAMING_SNAKE_CASE			)
  	UpperCAmelCase__:  int		       =   state_dict["encoder.embed_tokens.weight"].shape[0]
  
  	UpperCAmelCase__:  List[Any]		       =   PLBartConfig.from_pretrained(SCREAMING_SNAKE_CASE  ,vocab_size=SCREAMING_SNAKE_CASE			)
  
  	UpperCAmelCase__:  Any		       =   state_dict["decoder.embed_tokens.weight"]
  	if not classification:
  		UpperCAmelCase__:  Union[str, Any]		       =   PLBartForConditionalGeneration(SCREAMING_SNAKE_CASE			)
  		model.model.load_state_dict(SCREAMING_SNAKE_CASE			)
  		if finetuned:
  			UpperCAmelCase__:  List[str]		       =   make_linear_from_emb(model.model.shared			)
  
  	else:
  		UpperCAmelCase__:  Tuple		       =   {}
  		for key, value in state_dict.copy().items():
  			if key.startswith("classification_heads.sentence_classification_head"			):
  				UpperCAmelCase__:  Optional[int]		       =   value
  				state_dict.pop(SCREAMING_SNAKE_CASE			)
  		UpperCAmelCase__:  List[Any]		       =   PLBartForSequenceClassification(SCREAMING_SNAKE_CASE			)
  		model.model.load_state_dict(SCREAMING_SNAKE_CASE			)
  		model.classification_head.load_state_dict(SCREAMING_SNAKE_CASE			)
  
  	return model
  
  
  if __name__ == "__main__":
  			_lowerCAmelCase     :			Union[str, Any]    =argparse.ArgumentParser()
  			# Required parameters
  			parser.add_argument("""fairseq_path""", type=str, help="""model.pt on local filesystem.""")
  			parser.add_argument("""pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
  			parser.add_argument(
  			    """--hf_config""",
  			    default="""uclanlp/plbart-base""",
  			    type=str,
  			    help="""Which huggingface architecture to use: plbart-base""",
  			)
  			parser.add_argument("""--finetuned""", action="""store_true""", help="""whether the model is a fine-tuned checkpoint""")
  			parser.add_argument(
  			    """--classification""", action="""store_true""", help="""whether the model is a classification checkpoint"""
  			)
  			_lowerCAmelCase     :			Tuple    =parser.parse_args()
  			_lowerCAmelCase     :			List[Any]    =convert_fairseq_plbart_checkpoint_from_disk(
  			    args.fairseq_path,
  			    hf_config_path=args.hf_config,
  			    finetuned=args.finetuned,
  			    classification=args.classification,
  			)
  			model.save_pretrained(args.pytorch_dump_folder_path)
style_context: 
  
  from __future__ import annotations
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	assert n > 1 and a > 0 and greatest_common_divisor(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			) == 1
  	((UpperCAmelCase__)       ,	(UpperCAmelCase__)       ,	(UpperCAmelCase__)):  Optional[Any]		       =   extended_gcd(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)  # Implemented below
  	UpperCAmelCase__:  List[str]		       =   (b * s) % n
  	return x
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	((UpperCAmelCase__)       ,	(UpperCAmelCase__)):  int		       =   extended_euclid(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)  # Implemented below
  	if b < 0:
  		UpperCAmelCase__:  List[str]		       =   (b % n + n) % n
  	return b
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  Union[str, Any]		       =   invert_modulo(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)
  	UpperCAmelCase__:  Any		       =   (b * s) % n
  	return x
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	assert a >= 0 and b >= 0
  
  	if b == 0:
  		UpperCAmelCase__       ,	UpperCAmelCase__       ,	UpperCAmelCase__:  List[Any]		       =   a, 1, 0
  	else:
  		((UpperCAmelCase__)       ,	(UpperCAmelCase__)       ,	(UpperCAmelCase__)):  Tuple		       =   extended_gcd(SCREAMING_SNAKE_CASE  ,a % b			)
  		UpperCAmelCase__:  Union[str, Any]		       =   q
  		UpperCAmelCase__:  Union[str, Any]		       =   p - q * (a // b)
  
  	assert a % d == 0 and b % d == 0
  	assert d == a * x + b * y
  
  	return (d, x, y)
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	if b == 0:
  		return (1, 0)
  	((UpperCAmelCase__)       ,	(UpperCAmelCase__)):  List[str]		       =   extended_euclid(SCREAMING_SNAKE_CASE  ,a % b			)
  	UpperCAmelCase__:  Optional[Any]		       =   a // b
  	return (y, x - k * y)
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	if a < b:
  		UpperCAmelCase__       ,	UpperCAmelCase__:  str		       =   b, a
  
  	while a % b != 0:
  		UpperCAmelCase__       ,	UpperCAmelCase__:  Union[str, Any]		       =   b, a % b
  
  	return b
  
  
  if __name__ == "__main__":
  					from doctest import testmod
  
  					testmod(name="""modular_division""", verbose=True)
  					testmod(name="""modular_division2""", verbose=True)
  					testmod(name="""invert_modulo""", verbose=True)
  					testmod(name="""extended_gcd""", verbose=True)
  					testmod(name="""extended_euclid""", verbose=True)
  					testmod(name="""greatest_common_divisor""", verbose=True)