





'''simple docstring'''



def    _lowerCAmelCase						(				lowerCamelCase_			:  Optional[int]		,       lowerCamelCase_			:  Union[str, Any]				):
			__lowercase										=							''''''
			for i in table:
						res += inp[i - 1]
			return res




def    _lowerCAmelCase						(				lowerCamelCase_			:  Union[str, Any]				):
			return data[1:] + data[0]




def    _lowerCAmelCase						(				lowerCamelCase_			:  Union[str, Any]		,       lowerCamelCase_			:  Dict				):
			__lowercase										=							''''''
			for i in range(len(lowerCamelCase_				)				):
						if a[i] == b[i]:
									res += "0"
						else:
									res += "1"
			return res




def    _lowerCAmelCase						(				lowerCamelCase_			:  int		,       lowerCamelCase_			:  Optional[Any]				):
			__lowercase										=							int('''0b''' + data[0] + data[-1]		,       2				)
			__lowercase										=							int('''0b''' + data[1:3]		,       2				)
			return bin(s[row][col]				)[2:]




def    _lowerCAmelCase						(				lowerCamelCase_			:  Optional[Any]		,       lowerCamelCase_			:  Any		,       lowerCamelCase_			:  Union[str, Any]		,       lowerCamelCase_			:  Optional[Any]		,       lowerCamelCase_			:  Optional[int]				):
			__lowercase										=							message[:4]
			__lowercase										=							message[4:]
			__lowercase										=							apply_table(lowerCamelCase_		,       lowerCamelCase_				)
			__lowercase										=							xor(lowerCamelCase_		,       lowerCamelCase_				)
			__lowercase										=							apply_sbox(lowerCamelCase_		,       temp[:4]				)  # noqa: E741
			__lowercase										=							apply_sbox(lowerCamelCase_		,       temp[4:]				)
			__lowercase										=							'''0''' * (2 - len(lowerCamelCase_				)) + l  # noqa: E741
			__lowercase										=							'''0''' * (2 - len(lowerCamelCase_				)) + r
			__lowercase										=							apply_table(l + r		,       lowerCamelCase_				)
			__lowercase										=							xor(lowerCamelCase_		,       lowerCamelCase_				)
			return temp + right


if __name__ == "__main__":
	_SCREAMING_SNAKE_CASE					=    input('''Enter 10 bit key: ''')
	_SCREAMING_SNAKE_CASE					=    input('''Enter 8 bit message: ''')

	_SCREAMING_SNAKE_CASE					=    [6, 3, 7, 4, 8, 5, 1_0, 9]
	_SCREAMING_SNAKE_CASE					=    [3, 5, 2, 7, 4, 1_0, 1, 9, 8, 6]
	_SCREAMING_SNAKE_CASE					=    [2, 4, 3, 1]
	_SCREAMING_SNAKE_CASE					=    [2, 6, 3, 1, 4, 8, 5, 7]
	_SCREAMING_SNAKE_CASE					=    [4, 1, 3, 5, 7, 2, 8, 6]
	_SCREAMING_SNAKE_CASE					=    [4, 1, 2, 3, 2, 3, 4, 1]
	_SCREAMING_SNAKE_CASE					=    [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]]
	_SCREAMING_SNAKE_CASE					=    [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]]

	# key generation
	_SCREAMING_SNAKE_CASE					=    apply_table(key, paa_table)
	_SCREAMING_SNAKE_CASE					=    temp[:5]
	_SCREAMING_SNAKE_CASE					=    temp[5:]
	_SCREAMING_SNAKE_CASE					=    left_shift(left)
	_SCREAMING_SNAKE_CASE					=    left_shift(right)
	_SCREAMING_SNAKE_CASE					=    apply_table(left + right, pa_table)
	_SCREAMING_SNAKE_CASE					=    left_shift(left)
	_SCREAMING_SNAKE_CASE					=    left_shift(right)
	_SCREAMING_SNAKE_CASE					=    left_shift(left)
	_SCREAMING_SNAKE_CASE					=    left_shift(right)
	_SCREAMING_SNAKE_CASE					=    apply_table(left + right, pa_table)

	# encryption
	_SCREAMING_SNAKE_CASE					=    apply_table(message, IP)
	_SCREAMING_SNAKE_CASE					=    function(expansion, sa, sa, keya, temp)
	_SCREAMING_SNAKE_CASE					=    temp[4:] + temp[:4]
	_SCREAMING_SNAKE_CASE					=    function(expansion, sa, sa, keya, temp)
	_SCREAMING_SNAKE_CASE					=    apply_table(temp, IP_inv)
	print('''Cipher text is:''', CT)

	# decryption
	_SCREAMING_SNAKE_CASE					=    apply_table(CT, IP)
	_SCREAMING_SNAKE_CASE					=    function(expansion, sa, sa, keya, temp)
	_SCREAMING_SNAKE_CASE					=    temp[4:] + temp[:4]
	_SCREAMING_SNAKE_CASE					=    function(expansion, sa, sa, keya, temp)
	_SCREAMING_SNAKE_CASE					=    apply_table(temp, IP_inv)
	print('''Plain text after decypting is:''', PT)












'''simple docstring'''



import argparse
from pathlib import Path

import torch

from transformers import OPTConfig, OPTModel
from transformers.utils import logging


logging.set_verbosity_info()
_SCREAMING_SNAKE_CASE					=    logging.get_logger(__name__)




def    _lowerCAmelCase						(				lowerCamelCase_			:  int				):
			__lowercase										=							torch.load(lowerCamelCase_		,       map_location='''cpu'''				)
			if "model" in sd.keys():
						__lowercase										=							torch.load(lowerCamelCase_		,       map_location='''cpu'''				)['''model''']

			# pop unnecessary weights
			__lowercase										=							[
			    '''decoder.version''',
			    '''decoder.output_projection.weight''',
			]
			for key in keys_to_delete:
						if key in sd:
									sd.pop(lowerCamelCase_				)

			__lowercase										=							{
			    '''decoder.project_in_dim.weight''': '''decoder.project_in.weight''',
			    '''decoder.project_out_dim.weight''': '''decoder.project_out.weight''',
			    '''decoder.layer_norm.weight''': '''decoder.final_layer_norm.weight''',
			    '''decoder.layer_norm.bias''': '''decoder.final_layer_norm.bias''',
			}
			for old_key, new_key in keys_to_rename.items():
						if old_key in sd:
									__lowercase										=							sd.pop(lowerCamelCase_				)

			__lowercase										=							list(sd.keys()				)
			for key in keys:
						if ".qkv_proj." in key:
									__lowercase										=							sd[key]
									# We split QKV in separate Q,K,V

									__lowercase										=							key.replace('''.qkv_proj.'''		,       '''.q_proj.'''				)
									__lowercase										=							key.replace('''.qkv_proj.'''		,       '''.k_proj.'''				)
									__lowercase										=							key.replace('''.qkv_proj.'''		,       '''.v_proj.'''				)

									__lowercase										=							value.shape[0]
									assert depth % 3 == 0
									# `SequeuceParallelTransformerBlock` has QKV weight is separated in K,V,Q despite the naming:
									# https://cs.github.com/facebookresearch/metaseq/blob/51871bd73cd04c038f239ea2a26db1d7f6b37927/metaseq/modules/sequence_parallel_transformer_layer.py#L97
									__lowercase						,		__lowercase						,		__lowercase										=							torch.split(lowerCamelCase_		,       depth // 3		,       dim=0				)

									__lowercase										=							q
									__lowercase										=							k
									__lowercase										=							v
									del sd[key]

			return sd




@torch.no_grad()
def    _lowerCAmelCase						(				lowerCamelCase_			:  Union[str, Any]		,       lowerCamelCase_			:  Tuple		,       lowerCamelCase_			:  Union[str, Any]=None				):
			__lowercase										=							load_checkpoint(lowerCamelCase_				)

			if config is not None:
						__lowercase										=							OPTConfig.from_pretrained(lowerCamelCase_				)
			else:
						__lowercase										=							OPTConfig()

			__lowercase										=							OPTModel(lowerCamelCase_				).half().eval()
			model.load_state_dict(lowerCamelCase_				)

			# Check results
			Path(lowerCamelCase_				).mkdir(exist_ok=lowerCamelCase_				)
			model.save_pretrained(lowerCamelCase_				)


if __name__ == "__main__":
	_SCREAMING_SNAKE_CASE					=    argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    '''--fairseq_path''',
	    type=str,
	    help=(
	        '''path to fairseq checkpoint in correct format. You can find all checkpoints in the correct format here:'''
	        ''' https://huggingface.co/models?other=opt_metasq'''
	    ),
	)
	parser.add_argument('''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''')
	parser.add_argument('''--hf_config''', default=None, type=str, help='''Define HF config.''')
	_SCREAMING_SNAKE_CASE					=    parser.parse_args()
	convert_opt_checkpoint(args.fairseq_path, args.pytorch_dump_folder_path, config=args.hf_config)





