


import os
import re
import shutil
import sys
import tempfile
import unittest

import black


snake_case							:	Any					      =				os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, '''utils'''))

import check_copies  # noqa: E402


# This is the reference code that will be used in the tests.
# If BertLMPredictionHead is changed in modeling_bert.py, this code needs to be manually updated.
snake_case							:	Optional[int]					      =				'''    def __init__(self, config):
        super().__init__()
        self.transform = BertPredictionHeadTransform(config)

        # The output weights are the same as the input embeddings, but there is
        # an output-only bias for each token.
        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)

        self.bias = nn.Parameter(torch.zeros(config.vocab_size))

        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`
        self.decoder.bias = self.bias

    def forward(self, hidden_states):
        hidden_states = self.transform(hidden_states)
        hidden_states = self.decoder(hidden_states)
        return hidden_states
'''







class 	snake_case_       (unittest.TestCase				):
					def 			lowerCamelCase__(				self       :List[Any]				) ->   List[Any]:
												a__					=					tempfile.mkdtemp()
												os.makedirs(os.path.join(self.transformer_dir      ,'models/bert/'				)				)
												a__					=					self.transformer_dir
												shutil.copy(
												    os.path.join(__snake_case      ,'src/transformers/models/bert/modeling_bert.py'				)      ,os.path.join(self.transformer_dir      ,'models/bert/modeling_bert.py'				)      ,)
					def 			lowerCamelCase__(				self       :int				) ->   Optional[int]:
												a__					=					'src/transformers'
												shutil.rmtree(self.transformer_dir				)
					def 			lowerCamelCase__(				self       :Dict      ,__snake_case       :Optional[Any]      ,__snake_case       :Dict      ,__snake_case       :Union[str, Any]      ,__snake_case       :Union[str, Any]=None				) ->   Any:
												a__					=					comment + F'\nclass {class_name}(nn.Module):\n' + class_code
												if overwrite_result is not None:
																			a__					=					comment + F'\nclass {class_name}(nn.Module):\n' + overwrite_result
												a__					=					black.Mode(target_versions={black.TargetVersion.PYaa}      ,line_length=1_19				)
												a__					=					black.format_str(__snake_case      ,mode=__snake_case				)
												a__					=					os.path.join(self.transformer_dir      ,'new_code.py'				)
												with open(__snake_case      ,'w'      ,newline='\n'				) as f:
																			f.write(__snake_case				)
												if overwrite_result is None:
																			self.assertTrue(len(check_copies.is_copy_consistent(__snake_case				)				) == 0				)
												else:
																			check_copies.is_copy_consistent(f.name      ,overwrite=__snake_case				)
																			with open(__snake_case      ,'r'				) as f:
																										self.assertTrue(f.read()      ,__snake_case				)
					def 			lowerCamelCase__(				self       :Optional[int]				) ->   Optional[int]:
												a__					=					check_copies.find_code_in_transformers('models.bert.modeling_bert.BertLMPredictionHead'				)
												self.assertEqual(__snake_case      ,__snake_case				)
					def 			lowerCamelCase__(				self       :Tuple				) ->   Optional[Any]:
												# Base copy consistency
												self.check_copy_consistency(
												    '# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead'      ,'BertLMPredictionHead'      ,REFERENCE_CODE + '\n'      ,)

												# With no empty line at the end
												self.check_copy_consistency(
												    '# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead'      ,'BertLMPredictionHead'      ,__snake_case      ,)

												# Copy consistency with rename
												self.check_copy_consistency(
												    '# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel'      ,'TestModelLMPredictionHead'      ,re.sub('Bert'      ,'TestModel'      ,__snake_case				)      ,)

												# Copy consistency with a really long name
												a__					=					'TestModelWithAReallyLongNameBecauseSomePeopleLikeThatForSomeReason'
												self.check_copy_consistency(
												    F'# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->{long_class_name}'      ,F'{long_class_name}LMPredictionHead'      ,re.sub('Bert'      ,__snake_case      ,__snake_case				)      ,)

												# Copy consistency with overwrite
												self.check_copy_consistency(
												    '# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel'      ,'TestModelLMPredictionHead'      ,__snake_case      ,overwrite_result=re.sub('Bert'      ,'TestModel'      ,__snake_case				)      ,)



					def 			lowerCamelCase__(				self       :Tuple				) ->   List[Any]:
												a__					=					check_copies.LOCALIZED_READMES['README_zh-hans.md']

												a__					=					(
												    '1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the'
												    ' Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for'
												    ' Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong'
												    ' Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.\n1.'
												    ' **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (from HuggingFace),'
												    ' released together with the paper [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and'
												    ' lighter](https://arxiv.org/abs/1910.01108) by Victor Sanh, Lysandre Debut and Thomas Wolf. The same'
												    ' method has been applied to compress GPT2 into'
												    ' [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into'
												    ' [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),'
												    ' Multilingual BERT into'
												    ' [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German'
												    ' version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)**'
												    ' (from Google Research/Stanford University) released with the paper [ELECTRA: Pre-training text encoders'
												    ' as discriminators rather than generators](https://arxiv.org/abs/2003.10555) by Kevin Clark, Minh-Thang'
												    ' Luong, Quoc V. Le, Christopher D. Manning.'
												)
												a__					=					(
												    '1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the'
												    ' Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'
												    ' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'
												    ' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n'
												)
												a__					=					(
												    '1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the'
												    ' Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'
												    ' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'
												    ' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n1.'
												    ' **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (来自 HuggingFace) 伴随论文'
												    ' [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and'
												    ' lighter](https://arxiv.org/abs/1910.01108) 由 Victor Sanh, Lysandre Debut and Thomas Wolf 发布。 The same'
												    ' method has been applied to compress GPT2 into'
												    ' [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into'
												    ' [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),'
												    ' Multilingual BERT into'
												    ' [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German'
												    ' version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)** (来自'
												    ' Google Research/Stanford University) 伴随论文 [ELECTRA: Pre-training text encoders as discriminators rather'
												    ' than generators](https://arxiv.org/abs/2003.10555) 由 Kevin Clark, Minh-Thang Luong, Quoc V. Le,'
												    ' Christopher D. Manning 发布。\n'
												)

												a__				, a__					=					check_copies.convert_to_localized_md(
												    __snake_case      ,__snake_case      ,localized_readme['format_model_list']				)

												self.assertFalse(__snake_case				)
												self.assertEqual(__snake_case      ,__snake_case				)

												a__				, a__					=					check_copies.convert_to_localized_md(
												    __snake_case      ,__snake_case      ,localized_readme['format_model_list']				)

												# Check whether the number of models is equal to README.md after conversion.
												self.assertTrue(__snake_case				)

												a__					=					(
												    '1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the'
												    ' Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for'
												    ' Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong'
												    ' Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.'
												)
												a__					=					(
												    '1. **[ALBERT](https://huggingface.co/transformers/main/model_doc/albert.html)** (来自 Google Research and'
												    ' the Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'
												    ' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'
												    ' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n'
												)
												a__					=					(
												    '1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the'
												    ' Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'
												    ' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'
												    ' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n'
												)

												a__				, a__					=					check_copies.convert_to_localized_md(
												    __snake_case      ,__snake_case      ,localized_readme['format_model_list']				)

												# Check if the model link is synchronized.
												self.assertEqual(__snake_case      ,__snake_case				)





from collections import defaultdict
from math import ceil, sqrt






def 							__lowercase       (			__lowerCAmelCase							:    int = 1_0_0_0_0_0_0 ,   __lowerCAmelCase							:    int = 1_0       ):
							a__					=					defaultdict(__lowerCAmelCase       )

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

														hole_width_lower_bound += (outer_width - hole_width_lower_bound) % 2

														for hole_width in range(__lowerCAmelCase ,   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 <= 1_0       )


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




