





import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch
     from torch import nn

     from transformers import MaskFormerSwinBackbone
     from transformers.models.maskformer import MaskFormerSwinModel



class 							_UpperCAmelCase       :

  """simple docstring"""


  def __init__(							self					:						List[Any]   ,    lowerCAmelCase_					:						List[Any]   ,    lowerCAmelCase_					:						str=1_3   ,    lowerCAmelCase_					:						Union[str, Any]=3_2   ,    lowerCAmelCase_					:						Optional[Any]=2   ,    lowerCAmelCase_					:						str=3   ,    lowerCAmelCase_					:						Union[str, Any]=1_6   ,    lowerCAmelCase_					:						Any=[1, 2, 1]   ,    lowerCAmelCase_					:						Optional[Any]=[2, 2, 4]   ,    lowerCAmelCase_					:						str=2   ,    lowerCAmelCase_					:						str=2.0   ,    lowerCAmelCase_					:						Any=True   ,    lowerCAmelCase_					:						List[str]=0.0   ,    lowerCAmelCase_					:						Optional[int]=0.0   ,    lowerCAmelCase_					:						int=0.1   ,    lowerCAmelCase_					:						Any="gelu"   ,    lowerCAmelCase_					:						Optional[int]=False   ,    lowerCAmelCase_					:						Union[str, Any]=True   ,    lowerCAmelCase_					:						Optional[int]=0.02   ,    lowerCAmelCase_					:						int=1e-5   ,    lowerCAmelCase_					:						List[str]=True   ,    lowerCAmelCase_					:						Optional[Any]=None   ,    lowerCAmelCase_					:						int=True   ,    lowerCAmelCase_					:						List[Any]=1_0   ,    lowerCAmelCase_					:						Tuple=8   ,    lowerCAmelCase_					:						Optional[Any]=["stage1", "stage2", "stage3"]   ,    lowerCAmelCase_					:						Dict=[1, 2, 3]   ,    )				->		Optional[int]:
     __lowerCAmelCase				      =      parent
     __lowerCAmelCase				      =      batch_size
     __lowerCAmelCase				      =      image_size
     __lowerCAmelCase				      =      patch_size
     __lowerCAmelCase				      =      num_channels
     __lowerCAmelCase				      =      embed_dim
     __lowerCAmelCase				      =      depths
     __lowerCAmelCase				      =      num_heads
     __lowerCAmelCase				      =      window_size
     __lowerCAmelCase				      =      mlp_ratio
     __lowerCAmelCase				      =      qkv_bias
     __lowerCAmelCase				      =      hidden_dropout_prob
     __lowerCAmelCase				      =      attention_probs_dropout_prob
     __lowerCAmelCase				      =      drop_path_rate
     __lowerCAmelCase				      =      hidden_act
     __lowerCAmelCase				      =      use_absolute_embeddings
     __lowerCAmelCase				      =      patch_norm
     __lowerCAmelCase				      =      layer_norm_eps
     __lowerCAmelCase				      =      initializer_range
     __lowerCAmelCase				      =      is_training
     __lowerCAmelCase				      =      scope
     __lowerCAmelCase				      =      use_labels
     __lowerCAmelCase				      =      type_sequence_label_size
     __lowerCAmelCase				      =      encoder_stride
     __lowerCAmelCase				      =      out_features
     __lowerCAmelCase				      =      out_indices






  def 							lowercase						(							self					:						Dict	)				->		List[Any]:
     __lowerCAmelCase				      =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

     __lowerCAmelCase				      =      None
     if self.use_labels:
        __lowerCAmelCase				      =      ids_tensor([self.batch_size]   ,    self.type_sequence_label_size	)

     __lowerCAmelCase				      =      self.get_config()

     return config, pixel_values, labels






  def 							lowercase						(							self					:						Dict	)				->		Optional[int]:
     return MaskFormerSwinConfig(
         image_size=self.image_size   ,    patch_size=self.patch_size   ,    num_channels=self.num_channels   ,    embed_dim=self.embed_dim   ,    depths=self.depths   ,    num_heads=self.num_heads   ,    window_size=self.window_size   ,    mlp_ratio=self.mlp_ratio   ,    qkv_bias=self.qkv_bias   ,    hidden_dropout_prob=self.hidden_dropout_prob   ,    attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,    drop_path_rate=self.drop_path_rate   ,    hidden_act=self.hidden_act   ,    use_absolute_embeddings=self.use_absolute_embeddings   ,    path_norm=self.patch_norm   ,    layer_norm_eps=self.layer_norm_eps   ,    initializer_range=self.initializer_range   ,    encoder_stride=self.encoder_stride   ,    out_features=self.out_features   ,    out_indices=self.out_indices   ,    )






  def 							lowercase						(							self					:						Optional[Any]   ,    lowerCAmelCase_					:						Optional[Any]   ,    lowerCAmelCase_					:						Dict   ,    lowerCAmelCase_					:						Optional[int]	)				->		Union[str, Any]:
     __lowerCAmelCase				      =      MaskFormerSwinModel(config=lowerCAmelCase_	)
     model.to(lowerCAmelCase_	)
     model.eval()
     __lowerCAmelCase				      =      model(lowerCAmelCase_	)

     __lowerCAmelCase				      =      ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths	) - 1))
     __lowerCAmelCase				      =      int(config.embed_dim * 2 ** (len(config.depths	) - 1)	)

     self.parent.assertEqual(result.last_hidden_state.shape   ,    (self.batch_size, expected_seq_len, expected_dim)	)






  def 							lowercase						(							self					:						List[str]   ,    lowerCAmelCase_					:						int   ,    lowerCAmelCase_					:						Tuple   ,    lowerCAmelCase_					:						List[Any]	)				->		Optional[int]:
     __lowerCAmelCase				      =      MaskFormerSwinBackbone(config=lowerCAmelCase_	)
     model.to(lowerCAmelCase_	)
     model.eval()
     __lowerCAmelCase				      =      model(lowerCAmelCase_	)

     # verify feature maps
     self.parent.assertEqual(len(result.feature_maps	)   ,    len(config.out_features	)	)
     self.parent.assertListEqual(list(result.feature_maps[0].shape	)   ,    [1_3, 1_6, 1_6, 1_6]	)

     # verify channels
     self.parent.assertEqual(len(model.channels	)   ,    len(config.out_features	)	)
     self.parent.assertListEqual(model.channels   ,    [1_6, 3_2, 6_4]	)

     # verify ValueError
     with self.parent.assertRaises(lowerCAmelCase_	):
        __lowerCAmelCase				      =      ['stem']
        __lowerCAmelCase				      =      MaskFormerSwinBackbone(config=lowerCAmelCase_	)






  def 							lowercase						(							self					:						str	)				->		List[str]:
     __lowerCAmelCase				      =      self.prepare_config_and_inputs()
     __lowerCAmelCase      ,      __lowerCAmelCase      ,      __lowerCAmelCase				      =      config_and_inputs
     __lowerCAmelCase				      =      {'pixel_values': pixel_values}
     return config, inputs_dict





@require_torch
class 							_UpperCAmelCase       (       _UpperCamelCase						,       _UpperCamelCase						,       unittest.TestCase       ):

  """simple docstring"""


  a_              =					(
      (
          MaskFormerSwinModel,
          MaskFormerSwinBackbone,
      )
      if is_torch_available()
      else ()
  )
  a_              =					{"""feature-extraction""": MaskFormerSwinModel} if is_torch_available() else {}
  a_              =					False
  a_              =					False
  a_              =					False
  a_              =					False
  a_              =					False






  def 							lowercase						(							self					:						List[Any]	)				->		List[Any]:
     __lowerCAmelCase				      =      MaskFormerSwinModelTester(self	)
     __lowerCAmelCase				      =      ConfigTester(self   ,    config_class=lowerCAmelCase_   ,    embed_dim=3_7	)






  @require_torch_multi_gpu
  @unittest.skip(
      reason=(
          '`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn\'t work well with'
          ' `nn.DataParallel`'
      )	)
  def 							lowercase						(							self					:						Optional[Any]	)				->		List[Any]:
     pass






  def 							lowercase						(							self					:						Any	)				->		Optional[Any]:
     self.create_and_test_config_common_properties()
     self.config_tester.create_and_test_config_to_json_string()
     self.config_tester.create_and_test_config_to_json_file()
     self.config_tester.create_and_test_config_from_and_save_pretrained()
     self.config_tester.create_and_test_config_with_num_labels()
     self.config_tester.check_config_can_be_init_without_params()
     self.config_tester.check_config_arguments_init()






  def 							lowercase						(							self					:						List[Any]	)				->		List[str]:
     return






  def 							lowercase						(							self					:						List[Any]	)				->		Union[str, Any]:
     __lowerCAmelCase				      =      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowerCAmelCase_	)






  def 							lowercase						(							self					:						Union[str, Any]	)				->		List[str]:
     __lowerCAmelCase				      =      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_backbone(*lowerCAmelCase_	)






  @unittest.skip('Swin does not use inputs_embeds'	)
  def 							lowercase						(							self					:						Optional[Any]	)				->		str:
     pass






  @unittest.skip('Swin does not support feedforward chunking'	)
  def 							lowercase						(							self					:						Optional[int]	)				->		List[Any]:
     pass






  def 							lowercase						(							self					:						Any	)				->		List[Any]:
     __lowerCAmelCase      ,      __lowerCAmelCase				      =      self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        __lowerCAmelCase				      =      model_class(lowerCAmelCase_	)
        self.assertIsInstance(model.get_input_embeddings()   ,    (nn.Module)	)
        __lowerCAmelCase				      =      model.get_output_embeddings()
        self.assertTrue(x is None or isinstance(lowerCAmelCase_   ,    nn.Linear	)	)






  def 							lowercase						(							self					:						str	)				->		Union[str, Any]:
     __lowerCAmelCase      ,      __lowerCAmelCase				      =      self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        __lowerCAmelCase				      =      model_class(lowerCAmelCase_	)
        __lowerCAmelCase				      =      inspect.signature(model.forward	)
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        __lowerCAmelCase				      =      [*signature.parameters.keys()]

        __lowerCAmelCase				      =      ['pixel_values']
        self.assertListEqual(arg_names[:1]   ,    lowerCAmelCase_	)






  @unittest.skip(reason='MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'	)
  def 							lowercase						(							self					:						List[Any]	)				->		Optional[int]:
     pass






  @unittest.skip(reason='MaskFormerSwin is only used as an internal backbone'	)
  def 							lowercase						(							self					:						Dict	)				->		Any:
     pass






  def 							lowercase						(							self					:						Dict   ,    lowerCAmelCase_					:						List[str]   ,    lowerCAmelCase_					:						Optional[int]   ,    lowerCAmelCase_					:						Dict   ,    lowerCAmelCase_					:						Any	)				->		Union[str, Any]:
     __lowerCAmelCase				      =      model_class(lowerCAmelCase_	)
     model.to(lowerCAmelCase_	)
     model.eval()

     with torch.no_grad():
        __lowerCAmelCase				      =      model(**self._prepare_for_class(lowerCAmelCase_   ,    lowerCAmelCase_	)	)

     __lowerCAmelCase				      =      outputs.hidden_states

     __lowerCAmelCase				      =      getattr(
         self.model_tester   ,    'expected_num_hidden_layers'   ,    len(self.model_tester.depths	) + 1	)
     self.assertEqual(len(lowerCAmelCase_	)   ,    lowerCAmelCase_	)

     # Swin has a different seq_length
     __lowerCAmelCase				      =      (
         config.patch_size
         if isinstance(config.patch_size   ,    collections.abc.Iterable	)
         else (config.patch_size, config.patch_size)
     )

     __lowerCAmelCase				      =      (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

     self.assertListEqual(
         list(hidden_states[0].shape[-2:]	)   ,    [num_patches, self.model_tester.embed_dim]   ,    )






  def 							lowercase						(							self					:						int	)				->		Any:
     __lowerCAmelCase      ,      __lowerCAmelCase				      =      self.model_tester.prepare_config_and_inputs_for_common()

     __lowerCAmelCase				      =      (
         self.model_tester.image_size
         if isinstance(self.model_tester.image_size   ,    collections.abc.Iterable	)
         else (self.model_tester.image_size, self.model_tester.image_size)
     )

     for model_class in self.all_model_classes:
        __lowerCAmelCase				      =      True
        self.check_hidden_states_output(lowerCAmelCase_   ,    lowerCAmelCase_   ,    lowerCAmelCase_   ,    lowerCAmelCase_	)

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        __lowerCAmelCase				      =      True

        self.check_hidden_states_output(lowerCAmelCase_   ,    lowerCAmelCase_   ,    lowerCAmelCase_   ,    lowerCAmelCase_	)






  def 							lowercase						(							self					:						Dict	)				->		Union[str, Any]:
     __lowerCAmelCase      ,      __lowerCAmelCase				      =      self.model_tester.prepare_config_and_inputs_for_common()
     __lowerCAmelCase				      =      3

     __lowerCAmelCase				      =      (
         self.model_tester.image_size
         if isinstance(self.model_tester.image_size   ,    collections.abc.Iterable	)
         else (self.model_tester.image_size, self.model_tester.image_size)
     )
     __lowerCAmelCase				      =      (
         config.patch_size
         if isinstance(config.patch_size   ,    collections.abc.Iterable	)
         else (config.patch_size, config.patch_size)
     )

     __lowerCAmelCase				      =      image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
     __lowerCAmelCase				      =      image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

     for model_class in self.all_model_classes:
        __lowerCAmelCase				      =      True
        self.check_hidden_states_output(lowerCAmelCase_   ,    lowerCAmelCase_   ,    lowerCAmelCase_   ,    (padded_height, padded_width)	)

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        __lowerCAmelCase				      =      True
        self.check_hidden_states_output(lowerCAmelCase_   ,    lowerCAmelCase_   ,    lowerCAmelCase_   ,    (padded_height, padded_width)	)






  @unittest.skip(reason='MaskFormerSwin doesn\'t have pretrained checkpoints'	)
  def 							lowercase						(							self					:						Optional[int]	)				->		Optional[Any]:
     pass






  @unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'	)
  def 							lowercase						(							self					:						Optional[Any]	)				->		Dict:
     pass






  @unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'	)
  def 							lowercase						(							self					:						Tuple	)				->		List[str]:
     pass






  def 							lowercase						(							self					:						Union[str, Any]	)				->		Dict:
     __lowerCAmelCase      ,      __lowerCAmelCase				      =      self.model_tester.prepare_config_and_inputs_for_common()

     def set_nan_tensor_to_zero(lowerCAmelCase_					:						Dict	):
        __lowerCAmelCase				      =      0
        return t

     def check_equivalence(lowerCAmelCase_					:						Optional[int]   ,    lowerCAmelCase_					:						List[str]   ,    lowerCAmelCase_					:						Tuple   ,    lowerCAmelCase_					:						Any={}	):
        with torch.no_grad():
           __lowerCAmelCase				      =      model(**lowerCAmelCase_   ,    return_dict=lowerCAmelCase_   ,    **lowerCAmelCase_	)
           __lowerCAmelCase				      =      model(**lowerCAmelCase_   ,    return_dict=lowerCAmelCase_   ,    **lowerCAmelCase_	).to_tuple()

           def recursive_check(lowerCAmelCase_					:						Union[str, Any]   ,    lowerCAmelCase_					:						List[str]	):
              if isinstance(lowerCAmelCase_   ,    (List, Tuple)	):
                 for tuple_iterable_value, dict_iterable_value in zip(lowerCAmelCase_   ,    lowerCAmelCase_	):
                    recursive_check(lowerCAmelCase_   ,    lowerCAmelCase_	)
              elif isinstance(lowerCAmelCase_   ,    lowerCAmelCase_	):
                 for tuple_iterable_value, dict_iterable_value in zip(
                     tuple_object.values()   ,    dict_object.values()	):
                    recursive_check(lowerCAmelCase_   ,    lowerCAmelCase_	)
              elif tuple_object is None:
                 return
              else:
                 self.assertTrue(
                     torch.allclose(
                         set_nan_tensor_to_zero(lowerCAmelCase_	)   ,    set_nan_tensor_to_zero(lowerCAmelCase_	)   ,    atol=1e-5	)   ,    msg=(
                         'Tuple and dict output are not equal. Difference:'
                         f""" {torch.max(torch.abs(tuple_object - dict_object	)	)}. Tuple has `nan`:"""
                         f""" {torch.isnan(lowerCAmelCase_	).any()} and `inf`: {torch.isinf(lowerCAmelCase_	)}. Dict has"""
                         f""" `nan`: {torch.isnan(lowerCAmelCase_	).any()} and `inf`: {torch.isinf(lowerCAmelCase_	)}."""
                     )   ,    )

           recursive_check(lowerCAmelCase_   ,    lowerCAmelCase_	)

     for model_class in self.all_model_classes:
        __lowerCAmelCase				      =      model_class(lowerCAmelCase_	)
        model.to(lowerCAmelCase_	)
        model.eval()

        __lowerCAmelCase				      =      self._prepare_for_class(lowerCAmelCase_   ,    lowerCAmelCase_	)
        __lowerCAmelCase				      =      self._prepare_for_class(lowerCAmelCase_   ,    lowerCAmelCase_	)
        check_equivalence(lowerCAmelCase_   ,    lowerCAmelCase_   ,    lowerCAmelCase_	)

        __lowerCAmelCase				      =      self._prepare_for_class(lowerCAmelCase_   ,    lowerCAmelCase_   ,    return_labels=lowerCAmelCase_	)
        __lowerCAmelCase				      =      self._prepare_for_class(lowerCAmelCase_   ,    lowerCAmelCase_   ,    return_labels=lowerCAmelCase_	)
        check_equivalence(lowerCAmelCase_   ,    lowerCAmelCase_   ,    lowerCAmelCase_	)

        __lowerCAmelCase				      =      self._prepare_for_class(lowerCAmelCase_   ,    lowerCAmelCase_	)
        __lowerCAmelCase				      =      self._prepare_for_class(lowerCAmelCase_   ,    lowerCAmelCase_	)
        check_equivalence(lowerCAmelCase_   ,    lowerCAmelCase_   ,    lowerCAmelCase_   ,    {'output_hidden_states': True}	)

        __lowerCAmelCase				      =      self._prepare_for_class(lowerCAmelCase_   ,    lowerCAmelCase_   ,    return_labels=lowerCAmelCase_	)
        __lowerCAmelCase				      =      self._prepare_for_class(lowerCAmelCase_   ,    lowerCAmelCase_   ,    return_labels=lowerCAmelCase_	)
        check_equivalence(lowerCAmelCase_   ,    lowerCAmelCase_   ,    lowerCAmelCase_   ,    {'output_hidden_states': True}	)





@require_torch
class 							_UpperCAmelCase       (       unittest.TestCase						,       _UpperCamelCase       ):

  """simple docstring"""


  a_              =					(MaskFormerSwinBackbone,) if is_torch_available() else ()
  a_              =					MaskFormerSwinConfig






  def 							lowercase						(							self					:						List[str]	)				->		Dict:
     __lowerCAmelCase				      =      MaskFormerSwinModelTester(self	)






  def 							lowercase						(							self					:						Tuple	)				->		List[str]:
     __lowerCAmelCase      ,      __lowerCAmelCase				      =      self.model_tester.prepare_config_and_inputs_for_common()
     __lowerCAmelCase				      =      inputs_dict['pixel_values'].shape[0]

     for backbone_class in self.all_model_classes:
        __lowerCAmelCase				      =      backbone_class(lowerCAmelCase_	)
        backbone.to(lowerCAmelCase_	)
        backbone.eval()

        __lowerCAmelCase				      =      backbone(**lowerCAmelCase_	)

        # Test default outputs and verify feature maps
        self.assertIsInstance(outputs.feature_maps   ,    lowerCAmelCase_	)
        self.assertTrue(len(outputs.feature_maps	) == len(backbone.channels	)	)
        for feature_map, n_channels in zip(outputs.feature_maps   ,    backbone.channels	):
           self.assertTrue(feature_map.shape[:2]   ,    (batch_size, n_channels)	)
        self.assertIsNone(outputs.hidden_states	)
        self.assertIsNone(outputs.attentions	)

        # Test output_hidden_states=True
        __lowerCAmelCase				      =      backbone(**lowerCAmelCase_   ,    output_hidden_states=lowerCAmelCase_	)
        self.assertIsNotNone(outputs.hidden_states	)
        self.assertTrue(len(outputs.hidden_states	)   ,    len(backbone.stage_names	)	)
        # We skip the stem layer
        for hidden_states, n_channels in zip(outputs.hidden_states[1:]   ,    backbone.channels	):
           for hidden_state in hidden_states:
              # Hidden states are in the format (batch_size, (height * width), n_channels)
              __lowerCAmelCase      ,      __lowerCAmelCase      ,      __lowerCAmelCase				      =      hidden_state.shape
              self.assertTrue((h_batch_size, h_n_channels)   ,    (batch_size, n_channels)	)

            # Test output_attentions=True
        if self.has_attentions:
           __lowerCAmelCase				      =      backbone(**lowerCAmelCase_   ,    output_attentions=lowerCAmelCase_	)
           self.assertIsNotNone(outputs.attentions	)







'''simple docstring'''


from collections.abc import Generator
from math import sin
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							if len(UpperCamelCase ) != 32:
														raise ValueError('''Input must be of length 32''' )

							_a      	=							B''''''
							for i in [3, 2, 1, 0]:
														little_endian += string_aa[8 * i : 8 * i + 8]
							return little_endian
def 						snake_case_       (UpperCamelCase			:    int ):





							'''simple docstring'''


							if i < 0:
														raise ValueError('''Input must be non-negative''' )

							_a      	=							format(UpperCamelCase					,		'''08x''' )[-8:]
							_a      	=							B''''''
							for i in [3, 2, 1, 0]:
														little_endian_hex += hex_rep[2 * i : 2 * i + 2].encode('''utf-8''' )
							return little_endian_hex
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							_a      	=							B''''''
							for char in message:
														bit_string += format(UpperCamelCase					,		'''08b''' ).encode('''utf-8''' )
							_a      	=							format(len(UpperCamelCase )					,		'''064b''' ).encode('''utf-8''' )

							# Pad bit_string to a multiple of 512 chars
							bit_string += b"1"
							while len(UpperCamelCase ) % 512 != 448:
														bit_string += b"0"
							bit_string += to_little_endian(start_len[32:] ) + to_little_endian(start_len[:32] )

							return bit_string
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							if len(UpperCamelCase ) % 512 != 0:
														raise ValueError('''Input must have length that\'s a multiple of 512''' )

							for pos in range(0					,		len(UpperCamelCase )					,		512 ):
														_a      	=							bit_string[pos : pos + 512]
														_a      	=							[]
														for i in range(0					,		512					,		32 ):
																					block_words.append(int(to_little_endian(block[i : i + 32] )					,		2 ) )
														yield block_words
def 						snake_case_       (UpperCamelCase			:    int ):





							'''simple docstring'''


							if i < 0:
														raise ValueError('''Input must be non-negative''' )

							_a      	=							format(UpperCamelCase					,		'''032b''' )
							_a      	=							''''''
							for c in i_str:
														new_str += "1" if c == "0" else "0"
							return int(UpperCamelCase					,		2 )
def 						snake_case_       (UpperCamelCase			:    int					,		UpperCamelCase			:    int ):





							'''simple docstring'''


							return (a + b) % 2**32
def 						snake_case_       (UpperCamelCase			:    int					,		UpperCamelCase			:    int ):





							'''simple docstring'''


							if i < 0:
														raise ValueError('''Input must be non-negative''' )
							if shift < 0:
														raise ValueError('''Shift must be non-negative''' )
							return ((i << shift) ^ (i >> (32 - shift))) % 2**32
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							_a      	=							preprocess(UpperCamelCase )

							_a      	=							[int(2**32 * abs(sin(i + 1 ) ) ) for i in range(64 )]

							# Starting states
							_a      	=							0X67452301
							_a      	=							0Xefcdab89
							_a      	=							0X98badcfe
							_a      	=							0X10325476

							_a      	=							[
							    7,
							    12,
							    17,
							    22,
							    7,
							    12,
							    17,
							    22,
							    7,
							    12,
							    17,
							    22,
							    7,
							    12,
							    17,
							    22,
							    5,
							    9,
							    14,
							    20,
							    5,
							    9,
							    14,
							    20,
							    5,
							    9,
							    14,
							    20,
							    5,
							    9,
							    14,
							    20,
							    4,
							    11,
							    16,
							    23,
							    4,
							    11,
							    16,
							    23,
							    4,
							    11,
							    16,
							    23,
							    4,
							    11,
							    16,
							    23,
							    6,
							    10,
							    15,
							    21,
							    6,
							    10,
							    15,
							    21,
							    6,
							    10,
							    15,
							    21,
							    6,
							    10,
							    15,
							    21,
							]

							# Process bit string in chunks, each with 16 32-char words
							for block_words in get_block_words(UpperCamelCase ):
														_a      	=							aa
														_a      	=							ba
														_a      	=							ca
														_a      	=							da

														# Hash current chunk
														for i in range(64 ):
																					if i <= 15:
																												# f = (b & c) | (not_32(b) & d)     # Alternate definition for f
																												_a      	=							d ^ (b & (c ^ d))
																												_a      	=							i
																					elif i <= 31:
																												# f = (d & b) | (not_32(d) & c)     # Alternate definition for f
																												_a      	=							c ^ (d & (b ^ c))
																												_a      	=							(5 * i + 1) % 16
																					elif i <= 47:
																												_a      	=							b ^ c ^ d
																												_a      	=							(3 * i + 5) % 16
																					else:
																												_a      	=							c ^ (b | not_aa(UpperCamelCase ))
																												_a      	=							(7 * i) % 16
																					_a      	=							(f + a + added_consts[i] + block_words[g]) % 2**32
																					_a      	=							d
																					_a      	=							c
																					_a      	=							b
																					_a      	=							sum_aa(UpperCamelCase					,		left_rotate_aa(UpperCamelCase					,		shift_amounts[i] ) )

														# Add hashed chunk to running total
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )

							_a      	=							reformat_hex(UpperCamelCase ) + reformat_hex(UpperCamelCase ) + reformat_hex(UpperCamelCase ) + reformat_hex(UpperCamelCase )
							return digest


if __name__ == "__main__":
				import doctest

				doctest.testmod()

