





def       A__(		__lowerCAmelCase	,			__lowerCAmelCase ):
				if number < 0 or shift_amount < 0:
								raise ValueError('both inputs must be positive integers' )

				_snake_case :			Optional[int]  						=   str(bin(__lowerCAmelCase ) )
				binary_number += "0" * shift_amount
				return binary_number

def       A__(		__lowerCAmelCase	,			__lowerCAmelCase ):
				if number < 0 or shift_amount < 0:
								raise ValueError('both inputs must be positive integers' )

				_snake_case :			Dict  						=   str(bin(__lowerCAmelCase ) )[2:]
				if shift_amount >= len(__lowerCAmelCase ):
								return "0b0"
				_snake_case :			str  						=   binary_number[: len(__lowerCAmelCase ) - shift_amount]
				return "0b" + shifted_binary_number

def       A__(		__lowerCAmelCase	,			__lowerCAmelCase ):
				if number >= 0:  # Get binary representation of positive number
								_snake_case :			int  						=   '0' + str(bin(__lowerCAmelCase ) ).strip('-' )[2:]
				else:  # Get binary (2's complement) representation of negative number
								_snake_case :			str  						=   len(bin(__lowerCAmelCase )[3:] )  # Find 2's complement of number
								_snake_case :			Optional[Any]  						=   bin(abs(__lowerCAmelCase ) - (1 << binary_number_length) )[3:]
								_snake_case :			int  						=   (
								    '1' + '0' * (binary_number_length - len(__lowerCAmelCase )) + binary_number
								)

				if shift_amount >= len(__lowerCAmelCase ):
								return "0b" + binary_number[0] * len(__lowerCAmelCase )
				return (
				    "0b"
				    + binary_number[0] * shift_amount
				    + binary_number[: len(__lowerCAmelCase ) - shift_amount]
				)


if __name__ == "__main__":
		import doctest

		doctest.testmod()













import torch

from transformers import AutoModel


class 			lowercase				(							torch.nn.Module     ):



						"""simple docstring"""

						def __init__(    self			:		Tuple ,				lowerCamelCase_			:		Dict="sayef/fsner-bert-base-uncased"					):





										'''simple docstring'''







										super(lowerCamelCase_ ,				self					).__init__()

										_snake_case :			Optional[Any]  						=   AutoModel.from_pretrained(lowerCamelCase_ ,				return_dict=lowerCamelCase_					)
										_snake_case :			str  						=   torch.nn.CosineSimilarity(3 ,				1e-08					)
										_snake_case :			str  						=   torch.nn.Softmax(dim=1					)







						def 		__UpperCAmelCase       (    self			:		int ,				**lowerCamelCase_			:		List[str]					):





										'''simple docstring'''







										return self.bert(**lowerCamelCase_					).last_hidden_state







						def 		__UpperCAmelCase       (    self			:		List[Any] ,				lowerCamelCase_			:		Union[str, Any]					):





										'''simple docstring'''







										return token_embeddings.sum(2 ,				keepdim=lowerCamelCase_					)







						def 		__UpperCAmelCase       (    self			:		Dict ,				lowerCamelCase_			:		Dict ,				lowerCamelCase_			:		Tuple ,				lowerCamelCase_			:		Optional[Any]=1					):





										'''simple docstring'''







										return self.softmax(T * self.cos(lowerCamelCase_ ,				lowerCamelCase_					)					)







						def 		__UpperCAmelCase       (    self			:		Optional[Any] ,				lowerCamelCase_			:		Any ,				lowerCamelCase_			:		Union[str, Any]					):





										'''simple docstring'''







										_snake_case :			int  						=   W_supports['sizes'].tolist()
										_snake_case :			int  						=   W_supports['start_token_id'].item()
										_snake_case :			List[str]  						=   W_supports['end_token_id'].item()

										del W_supports["sizes"]
										del W_supports["start_token_id"]
										del W_supports["end_token_id"]

										_snake_case :			Optional[int]  						=   self.BERT(**lowerCamelCase_					)
										_snake_case :			Optional[Any]  						=   self.BERT(**lowerCamelCase_					)

										_snake_case :			Optional[int]  						=   None
										_snake_case :			Optional[int]  						=   None

										_snake_case :			List[str]  						=   W_supports['input_ids'] == start_token_id
										_snake_case :			Union[str, Any]  						=   W_supports['input_ids'] == end_token_id

										for i, size in enumerate(lowerCamelCase_					):
														if i == 0:
																		_snake_case :			str  						=   0
														else:
																		_snake_case :			Union[str, Any]  						=   support_sizes[i - 1]

														_snake_case :			Tuple  						=   S[s : s + size][start_token_masks[s : s + size]]
														_snake_case :			Optional[int]  						=   S[s : s + size][end_token_masks[s : s + size]]

														_snake_case :			Tuple  						=   torch.matmul(q[i] ,				s_start.T					).sum(1					).softmax(0					)
														_snake_case :			Union[str, Any]  						=   torch.matmul(q[i] ,				s_end.T					).sum(1					).softmax(0					)

														if p_starts is not None:
																		_snake_case :			Optional[Any]  						=   torch.vstack((p_starts, p_start)					)
																		_snake_case :			List[str]  						=   torch.vstack((p_ends, p_end)					)
														else:
																		_snake_case :			Union[str, Any]  						=   p_start
																		_snake_case :			Any  						=   p_end

										return p_starts, p_ends






