

"""simple docstring"""





import torch

from transformers import AutoModel







class 				SCREAMING_SNAKE_CASE					(		torch.nn.Module       ):






					"""simple docstring"""



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

						lowerCAmelCase__	:						int  				=	AutoModel.from_pretrained(lowercase_   ,return_dict=lowercase_		)
						lowerCAmelCase__	:						Optional[int]  				=	torch.nn.CosineSimilarity(3   ,1E-08		)
						lowerCAmelCase__	:						List[str]  				=	torch.nn.Softmax(dim=1		)







					def        __lowerCAmelCase (       self			:				str   ,**lowercase_			:				int		):
						return self.bert(**lowercase_		).last_hidden_state







					def        __lowerCAmelCase (       self			:				List[Any]   ,lowercase_			:				Optional[int]		):
						return token_embeddings.sum(2   ,keepdim=lowercase_		)







					def        __lowerCAmelCase (       self			:				Dict   ,lowercase_			:				int   ,lowercase_			:				str   ,lowercase_			:				Tuple=1		):
						return self.softmax(T * self.cos(lowercase_   ,lowercase_		)		)







					def        __lowerCAmelCase (       self			:				Optional[Any]   ,lowercase_			:				str   ,lowercase_			:				Union[str, Any]		):
						lowerCAmelCase__	:						List[Any]  				=	W_supports['''sizes'''].tolist()
						lowerCAmelCase__	:						Dict  				=	W_supports['''start_token_id'''].item()
						lowerCAmelCase__	:						Union[str, Any]  				=	W_supports['''end_token_id'''].item()

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

						lowerCAmelCase__	:						Optional[Any]  				=	self.BERT(**lowercase_		)
						lowerCAmelCase__	:						int  				=	self.BERT(**lowercase_		)

						lowerCAmelCase__	:						List[str]  				=	None
						lowerCAmelCase__	:						Union[str, Any]  				=	None

						lowerCAmelCase__	:						int  				=	W_supports['''input_ids'''] == start_token_id
						lowerCAmelCase__	:						Optional[Any]  				=	W_supports['''input_ids'''] == end_token_id

						for i, size in enumerate(lowercase_		):
							if i == 0:
								lowerCAmelCase__	:						str  				=	0
							else:
								lowerCAmelCase__	:						List[Any]  				=	support_sizes[i - 1]

							lowerCAmelCase__	:						Optional[Any]  				=	S[s : s + size][start_token_masks[s : s + size]]
							lowerCAmelCase__	:						List[Any]  				=	S[s : s + size][end_token_masks[s : s + size]]

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

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

						return p_starts, p_ends







"""simple docstring"""





from collections import defaultdict
from math import ceil, sqrt

def   __SCREAMING_SNAKE_CASE  (      A_ = 1_00_00_00						,     A_ = 10 ):
	lowerCAmelCase__	:						defaultdict  				=	defaultdict(A_ )

	for outer_width in range(3						,     (t_limit // 4) + 2 ):
		if outer_width * outer_width > t_limit:
			lowerCAmelCase__	:						int  				=	max(
			    ceil(sqrt(outer_width * outer_width - t_limit ) )						,     1 )
		else:
			lowerCAmelCase__	:						Tuple  				=	1

		hole_width_lower_bound += (outer_width - hole_width_lower_bound) % 2

		for hole_width in range(A_						,     outer_width - 1						,     2 ):
			count[outer_width * outer_width - hole_width * hole_width] += 1

	return sum(1 for n in count.values() if 1 <= n <= 10 )


if __name__ == "__main__":
							print(F'''{solution() = }''')




