





'''simple docstring'''







import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
snake_case_     :       List[Any]						=  logging.get_logger(__name__)

def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			Dict   ) ->	Any:
						UpperCAmelCase_			:      Optional[int]     						=  SwinConfig(
						    embed_dim=192,			depths=(2, 2, 18, 2),			num_heads=(6, 12, 24, 48),			window_size=12,			out_features=['''stage2''', '''stage3''', '''stage4'''],			)

						UpperCAmelCase_			:      Optional[int]     						=  DetaConfig(
						    backbone_config=SCREAMING_SNAKE_CASE__,			num_queries=900,			encoder_ffn_dim=2048,			decoder_ffn_dim=2048,			num_feature_levels=5,			assign_first_stage=SCREAMING_SNAKE_CASE__,			with_box_refine=SCREAMING_SNAKE_CASE__,			two_stage=SCREAMING_SNAKE_CASE__,			)

						# set labels
						UpperCAmelCase_			:      Any     						=  '''huggingface/label-files'''
						if "o365" in model_name:
												UpperCAmelCase_			:      List[Any]     						=  366
												UpperCAmelCase_			:      Any     						=  '''object365-id2label.json'''
						else:
												UpperCAmelCase_			:      List[Any]     						=  91
												UpperCAmelCase_			:      List[str]     						=  '''coco-detection-id2label.json'''

						UpperCAmelCase_			:      Dict     						=  num_labels
						UpperCAmelCase_			:      Optional[Any]     						=  json.load(open(cached_download(hf_hub_url(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__,			repo_type='''dataset'''   )   ),			'''r'''   )   )
						UpperCAmelCase_			:      int     						=  {int(SCREAMING_SNAKE_CASE__   ): v for k, v in idalabel.items()}
						UpperCAmelCase_			:      Any     						=  idalabel
						UpperCAmelCase_			:      Tuple     						=  {v: k for k, v in idalabel.items()}

						return config

def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			Dict   ) ->	Optional[int]:
						UpperCAmelCase_			:      List[Any]     						=  []

						# stem
						# fmt: off
						rename_keys.append(('''backbone.0.body.patch_embed.proj.weight''', '''model.backbone.model.embeddings.patch_embeddings.projection.weight''')   )
						rename_keys.append(('''backbone.0.body.patch_embed.proj.bias''', '''model.backbone.model.embeddings.patch_embeddings.projection.bias''')   )
						rename_keys.append(('''backbone.0.body.patch_embed.norm.weight''', '''model.backbone.model.embeddings.norm.weight''')   )
						rename_keys.append(('''backbone.0.body.patch_embed.norm.bias''', '''model.backbone.model.embeddings.norm.bias''')   )
						# stages
						for i in range(len(config.backbone_config.depths   )   ):
												for j in range(config.backbone_config.depths[i]   ):
																		rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm1.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight""")   )
																		rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm1.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias""")   )
																		rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table""")   )
																		rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index""")   )
																		rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight""")   )
																		rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias""")   )
																		rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm2.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight""")   )
																		rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm2.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias""")   )
																		rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight""")   )
																		rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias""")   )
																		rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight""")   )
																		rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias""")   )

												if i < 3:
																		rename_keys.append((F"""backbone.0.body.layers.{i}.downsample.reduction.weight""", F"""model.backbone.model.encoder.layers.{i}.downsample.reduction.weight""")   )
																		rename_keys.append((F"""backbone.0.body.layers.{i}.downsample.norm.weight""", F"""model.backbone.model.encoder.layers.{i}.downsample.norm.weight""")   )
																		rename_keys.append((F"""backbone.0.body.layers.{i}.downsample.norm.bias""", F"""model.backbone.model.encoder.layers.{i}.downsample.norm.bias""")   )

						rename_keys.append(('''backbone.0.body.norm1.weight''', '''model.backbone.model.hidden_states_norms.stage2.weight''')   )
						rename_keys.append(('''backbone.0.body.norm1.bias''', '''model.backbone.model.hidden_states_norms.stage2.bias''')   )
						rename_keys.append(('''backbone.0.body.norm2.weight''', '''model.backbone.model.hidden_states_norms.stage3.weight''')   )
						rename_keys.append(('''backbone.0.body.norm2.bias''', '''model.backbone.model.hidden_states_norms.stage3.bias''')   )
						rename_keys.append(('''backbone.0.body.norm3.weight''', '''model.backbone.model.hidden_states_norms.stage4.weight''')   )
						rename_keys.append(('''backbone.0.body.norm3.bias''', '''model.backbone.model.hidden_states_norms.stage4.bias''')   )

						# transformer encoder
						for i in range(config.encoder_layers   ):
												rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight""", F"""model.encoder.layers.{i}.self_attn.sampling_offsets.weight""")   )
												rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias""", F"""model.encoder.layers.{i}.self_attn.sampling_offsets.bias""")   )
												rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.attention_weights.weight""", F"""model.encoder.layers.{i}.self_attn.attention_weights.weight""")   )
												rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.attention_weights.bias""", F"""model.encoder.layers.{i}.self_attn.attention_weights.bias""")   )
												rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.value_proj.weight""", F"""model.encoder.layers.{i}.self_attn.value_proj.weight""")   )
												rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.value_proj.bias""", F"""model.encoder.layers.{i}.self_attn.value_proj.bias""")   )
												rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.output_proj.weight""", F"""model.encoder.layers.{i}.self_attn.output_proj.weight""")   )
												rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.output_proj.bias""", F"""model.encoder.layers.{i}.self_attn.output_proj.bias""")   )
												rename_keys.append((F"""transformer.encoder.layers.{i}.norm1.weight""", F"""model.encoder.layers.{i}.self_attn_layer_norm.weight""")   )
												rename_keys.append((F"""transformer.encoder.layers.{i}.norm1.bias""", F"""model.encoder.layers.{i}.self_attn_layer_norm.bias""")   )
												rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.weight""", F"""model.encoder.layers.{i}.fc1.weight""")   )
												rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.bias""", F"""model.encoder.layers.{i}.fc1.bias""")   )
												rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.weight""", F"""model.encoder.layers.{i}.fc2.weight""")   )
												rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.bias""", F"""model.encoder.layers.{i}.fc2.bias""")   )
												rename_keys.append((F"""transformer.encoder.layers.{i}.norm2.weight""", F"""model.encoder.layers.{i}.final_layer_norm.weight""")   )
												rename_keys.append((F"""transformer.encoder.layers.{i}.norm2.bias""", F"""model.encoder.layers.{i}.final_layer_norm.bias""")   )

						# transformer decoder
						for i in range(config.decoder_layers   ):
												rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight""", F"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias""", F"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.attention_weights.weight""", F"""model.decoder.layers.{i}.encoder_attn.attention_weights.weight""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.attention_weights.bias""", F"""model.decoder.layers.{i}.encoder_attn.attention_weights.bias""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.value_proj.weight""", F"""model.decoder.layers.{i}.encoder_attn.value_proj.weight""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.value_proj.bias""", F"""model.decoder.layers.{i}.encoder_attn.value_proj.bias""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.output_proj.weight""", F"""model.decoder.layers.{i}.encoder_attn.output_proj.weight""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.output_proj.bias""", F"""model.decoder.layers.{i}.encoder_attn.output_proj.bias""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.norm1.weight""", F"""model.decoder.layers.{i}.encoder_attn_layer_norm.weight""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.norm1.bias""", F"""model.decoder.layers.{i}.encoder_attn_layer_norm.bias""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.self_attn.out_proj.weight""", F"""model.decoder.layers.{i}.self_attn.out_proj.weight""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.self_attn.out_proj.bias""", F"""model.decoder.layers.{i}.self_attn.out_proj.bias""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.norm2.weight""", F"""model.decoder.layers.{i}.self_attn_layer_norm.weight""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.norm2.bias""", F"""model.decoder.layers.{i}.self_attn_layer_norm.bias""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.weight""", F"""model.decoder.layers.{i}.fc1.weight""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.bias""", F"""model.decoder.layers.{i}.fc1.bias""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.weight""", F"""model.decoder.layers.{i}.fc2.weight""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.bias""", F"""model.decoder.layers.{i}.fc2.bias""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.norm3.weight""", F"""model.decoder.layers.{i}.final_layer_norm.weight""")   )
												rename_keys.append((F"""transformer.decoder.layers.{i}.norm3.bias""", F"""model.decoder.layers.{i}.final_layer_norm.bias""")   )

						# fmt: on

						return rename_keys

def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			Any,			SCREAMING_SNAKE_CASE__      :			List[Any],			SCREAMING_SNAKE_CASE__      :			int   ) ->	Dict:
						UpperCAmelCase_			:      str     						=  dct.pop(SCREAMING_SNAKE_CASE__   )
						UpperCAmelCase_			:      int     						=  val

def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			Tuple,			SCREAMING_SNAKE_CASE__      :			Tuple   ) ->	List[Any]:
						UpperCAmelCase_			:      List[Any]     						=  [int(backbone_config.embed_dim * 2**i   ) for i in range(len(backbone_config.depths   )   )]
						for i in range(len(backbone_config.depths   )   ):
												UpperCAmelCase_			:      str     						=  num_features[i]
												for j in range(backbone_config.depths[i]   ):
																		# fmt: off
																		# read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
																		UpperCAmelCase_			:      Union[str, Any]     						=  state_dict.pop(F"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight"""   )
																		UpperCAmelCase_			:      str     						=  state_dict.pop(F"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias"""   )
																		# next, add query, keys and values (in that order) to the state dict
																		UpperCAmelCase_			:      Optional[int]     						=  in_proj_weight[:dim, :]
																		UpperCAmelCase_			:      List[str]     						=  in_proj_bias[: dim]
																		UpperCAmelCase_			:      int     						=  in_proj_weight[
																		    dim : dim * 2, :
																		]
																		UpperCAmelCase_			:      Optional[Any]     						=  in_proj_bias[
																		    dim : dim * 2
																		]
																		UpperCAmelCase_			:      List[str]     						=  in_proj_weight[
																		    -dim :, :
																		]
																		UpperCAmelCase_			:      Dict     						=  in_proj_bias[-dim :]
																		# fmt: on

def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			int,			SCREAMING_SNAKE_CASE__      :			List[Any]   ) ->	Any:
						# transformer decoder self-attention layers
						UpperCAmelCase_			:      List[Any]     						=  config.d_model
						for i in range(config.decoder_layers   ):
												# read in weights + bias of input projection layer of self-attention
												UpperCAmelCase_			:      List[str]     						=  state_dict.pop(F"""transformer.decoder.layers.{i}.self_attn.in_proj_weight"""   )
												UpperCAmelCase_			:      List[str]     						=  state_dict.pop(F"""transformer.decoder.layers.{i}.self_attn.in_proj_bias"""   )
												# next, add query, keys and values (in that order) to the state dict
												UpperCAmelCase_			:      str     						=  in_proj_weight[:hidden_size, :]
												UpperCAmelCase_			:      Tuple     						=  in_proj_bias[:hidden_size]
												UpperCAmelCase_			:      Any     						=  in_proj_weight[
												    hidden_size : hidden_size * 2, :
												]
												UpperCAmelCase_			:      Optional[int]     						=  in_proj_bias[hidden_size : hidden_size * 2]
												UpperCAmelCase_			:      Optional[Any]     						=  in_proj_weight[-hidden_size:, :]
												UpperCAmelCase_			:      List[Any]     						=  in_proj_bias[-hidden_size:]

def        lowerCamelCase_      (  ) ->	Any:
						UpperCAmelCase_			:      Any     						=  '''http://images.cocodataset.org/val2017/000000039769.jpg'''
						UpperCAmelCase_			:      Any     						=  Image.open(requests.get(SCREAMING_SNAKE_CASE__,			stream=SCREAMING_SNAKE_CASE__   ).raw   )

						return im

@torch.no_grad()
def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			Tuple,			SCREAMING_SNAKE_CASE__      :			Union[str, Any],			SCREAMING_SNAKE_CASE__      :			Union[str, Any]   ) ->	Any:
						UpperCAmelCase_			:      List[str]     						=  get_deta_config(SCREAMING_SNAKE_CASE__   )

						# load original state dict
						if model_name == "deta-swin-large":
												UpperCAmelCase_			:      int     						=  hf_hub_download(repo_id='''nielsr/deta-checkpoints''',			filename='''adet_swin_ft.pth'''   )
						elif model_name == "deta-swin-large-o365":
												UpperCAmelCase_			:      Dict     						=  hf_hub_download(repo_id='''jozhang97/deta-swin-l-o365''',			filename='''deta_swin_pt_o365.pth'''   )
						else:
												raise ValueError(F"""Model name {model_name} not supported"""   )

						UpperCAmelCase_			:      Any     						=  torch.load(SCREAMING_SNAKE_CASE__,			map_location='''cpu'''   )['''model''']

						# original state dict
						for name, param in state_dict.items():
												print(SCREAMING_SNAKE_CASE__,			param.shape   )

						# rename keys
						UpperCAmelCase_			:      Dict     						=  create_rename_keys(SCREAMING_SNAKE_CASE__   )
						for src, dest in rename_keys:
												rename_key(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   )
						read_in_swin_q_k_v(SCREAMING_SNAKE_CASE__,			config.backbone_config   )
						read_in_decoder_q_k_v(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   )

						# fix some prefixes
						for key in state_dict.copy().keys():
												if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
																		UpperCAmelCase_			:      Union[str, Any]     						=  state_dict.pop(SCREAMING_SNAKE_CASE__   )
																		UpperCAmelCase_			:      Tuple     						=  val
												if "input_proj" in key:
																		UpperCAmelCase_			:      List[str]     						=  state_dict.pop(SCREAMING_SNAKE_CASE__   )
																		UpperCAmelCase_			:      Tuple     						=  val
												if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
																		UpperCAmelCase_			:      Union[str, Any]     						=  state_dict.pop(SCREAMING_SNAKE_CASE__   )
																		UpperCAmelCase_			:      List[str]     						=  val

    # finally, create HuggingFace model and load state dict
						UpperCAmelCase_			:      int     						=  DetaForObjectDetection(SCREAMING_SNAKE_CASE__   )
						model.load_state_dict(SCREAMING_SNAKE_CASE__   )
						model.eval()

						UpperCAmelCase_			:      int     						=  '''cuda''' if torch.cuda.is_available() else '''cpu'''
						model.to(SCREAMING_SNAKE_CASE__   )

						# load image processor
						UpperCAmelCase_			:      Union[str, Any]     						=  DetaImageProcessor(format='''coco_detection'''   )

						# verify our conversion on image
						UpperCAmelCase_			:      str     						=  prepare_img()
						UpperCAmelCase_			:      str     						=  processor(images=SCREAMING_SNAKE_CASE__,			return_tensors='''pt'''   )
						UpperCAmelCase_			:      Union[str, Any]     						=  encoding['''pixel_values''']
						UpperCAmelCase_			:      str     						=  model(pixel_values.to(SCREAMING_SNAKE_CASE__   )   )

						# verify logits
						print('''Logits:''',			outputs.logits[0, :3, :3]   )
						print('''Boxes:''',			outputs.pred_boxes[0, :3, :3]   )
						if model_name == "deta-swin-large":
												UpperCAmelCase_			:      List[str]     						=  torch.tensor(
												    [[-7.63_08, -2.84_85, -5.37_37], [-7.20_37, -4.55_05, -4.80_27], [-7.29_43, -4.26_11, -4.66_17]]   )
												UpperCAmelCase_			:      int     						=  torch.tensor([[0.49_87, 0.49_69, 0.99_99], [0.25_49, 0.54_98, 0.48_05], [0.54_98, 0.27_57, 0.05_69]]   )
						elif model_name == "deta-swin-large-o365":
												UpperCAmelCase_			:      Optional[int]     						=  torch.tensor(
												    [[-8.01_22, -3.57_20, -4.97_17], [-8.15_47, -3.68_86, -4.63_89], [-7.66_10, -3.61_94, -5.01_34]]   )
												UpperCAmelCase_			:      Optional[int]     						=  torch.tensor([[0.25_23, 0.55_49, 0.48_81], [0.77_15, 0.41_49, 0.46_01], [0.55_03, 0.27_53, 0.05_75]]   )
						assert torch.allclose(outputs.logits[0, :3, :3],			expected_logits.to(SCREAMING_SNAKE_CASE__   ),			atol=1E-4   )
						assert torch.allclose(outputs.pred_boxes[0, :3, :3],			expected_boxes.to(SCREAMING_SNAKE_CASE__   ),			atol=1E-4   )
						print('''Everything ok!'''   )

						if pytorch_dump_folder_path:
												# Save model and processor
												logger.info(F"""Saving PyTorch model and processor to {pytorch_dump_folder_path}..."""   )
												Path(SCREAMING_SNAKE_CASE__   ).mkdir(exist_ok=SCREAMING_SNAKE_CASE__   )
												model.save_pretrained(SCREAMING_SNAKE_CASE__   )
												processor.save_pretrained(SCREAMING_SNAKE_CASE__   )

						# Push to hub
						if push_to_hub:
												print('''Pushing model and processor to hub...'''   )
												model.push_to_hub(F"""jozhang97/{model_name}"""   )
												processor.push_to_hub(F"""jozhang97/{model_name}"""   )


if __name__ == "__main__":
					snake_case_     :       Any						=  argparse.ArgumentParser()

					parser.add_argument(
					    "--model_name",
					    type=str,
					    default="deta-swin-large",
					    choices=["deta-swin-large", "deta-swin-large-o365"],
					    help="Name of the model you'd like to convert.",
					)
					parser.add_argument(
					    "--pytorch_dump_folder_path",
					    default=None,
					    type=str,
					    help="Path to the folder to output PyTorch model.",
					)
					parser.add_argument(
					    "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
					)
					snake_case_     :       List[str]						=  parser.parse_args()
					convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)












'''simple docstring'''







def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			int   ) ->	str:
						if number > 0:
												raise ValueError('''input must be a negative integer'''   )
						UpperCAmelCase_			:      Union[str, Any]     						=  len(bin(SCREAMING_SNAKE_CASE__   )[3:]   )
						UpperCAmelCase_			:      Union[str, Any]     						=  bin(abs(SCREAMING_SNAKE_CASE__   ) - (1 << binary_number_length)   )[3:]
						UpperCAmelCase_			:      Optional[Any]     						=  (
						    (
						        '''1'''
						        + '''0''' * (binary_number_length - len(SCREAMING_SNAKE_CASE__   ))
						        + twos_complement_number
						    )
						    if number < 0
						    else '''0'''
						)
						return "0b" + twos_complement_number


if __name__ == "__main__":
					import doctest

					doctest.testmod()





