



"""simple docstring"""







import argparse
import json
import pickle
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, MaskFormerImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
A		=						logging.get_logger(__name__)

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							str ):
						"""simple docstring"""






						snake_case   :			Optional[Any]						    = SwinConfig.from_pretrained(
						    "microsoft/swin-tiny-patch4-window7-224"     ,		out_features=["stage1", "stage2", "stage3", "stage4"] )
						snake_case   :			List[str]						    = MaskFormerConfig(backbone_config=lowerCamelCase_ )

						snake_case   :			Optional[Any]						    = "huggingface/label-files"
						if "ade20k-full" in model_name:
												# this should be ok
												snake_case   :			List[str]						    = 8_4_7
												snake_case   :			str						    = "maskformer-ade20k-full-id2label.json"
						elif "ade" in model_name:
												# this should be ok
												snake_case   :			Dict						    = 1_5_0
												snake_case   :			Dict						    = "ade20k-id2label.json"
						elif "coco-stuff" in model_name:
												# this should be ok
												snake_case   :			int						    = 1_7_1
												snake_case   :			Optional[Any]						    = "maskformer-coco-stuff-id2label.json"
						elif "coco" in model_name:
												# TODO
												snake_case   :			Optional[int]						    = 1_3_3
												snake_case   :			List[Any]						    = "coco-panoptic-id2label.json"
						elif "cityscapes" in model_name:
												# this should be ok
												snake_case   :			Optional[Any]						    = 1_9
												snake_case   :			Union[str, Any]						    = "cityscapes-id2label.json"
						elif "vistas" in model_name:
												# this should be ok
												snake_case   :			Any						    = 6_5
												snake_case   :			List[Any]						    = "mapillary-vistas-id2label.json"

						snake_case   :			Dict						    = json.load(open(hf_hub_download(lowerCamelCase_     ,		lowerCamelCase_     ,		repo_type="dataset" )     ,		"r" ) )
						snake_case   :			Any						    = {int(lowerCamelCase_ ): v for k, v in idalabel.items()}

						return config

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							Union[str, Any] ):
						"""simple docstring"""






						snake_case   :			Tuple						    = []
						# stem
						# fmt: off
						rename_keys.append(("backbone.patch_embed.proj.weight", "model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.weight") )
						rename_keys.append(("backbone.patch_embed.proj.bias", "model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.bias") )
						rename_keys.append(("backbone.patch_embed.norm.weight", "model.pixel_level_module.encoder.model.embeddings.norm.weight") )
						rename_keys.append(("backbone.patch_embed.norm.bias", "model.pixel_level_module.encoder.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.layers.{i}.blocks.{j}.norm1.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight''') )
																		rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.norm1.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias''') )
																		rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.attn.relative_position_bias_table''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table''') )
																		rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.attn.relative_position_index''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index''') )
																		rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.attn.proj.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight''') )
																		rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.attn.proj.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias''') )
																		rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.norm2.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight''') )
																		rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.norm2.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias''') )
																		rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.mlp.fc1.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight''') )
																		rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.mlp.fc1.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias''') )
																		rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.mlp.fc2.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.weight''') )
																		rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.mlp.fc2.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.bias''') )

												if i < 3:
																		rename_keys.append((f'''backbone.layers.{i}.downsample.reduction.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.reduction.weight''') )
																		rename_keys.append((f'''backbone.layers.{i}.downsample.norm.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.weight''') )
																		rename_keys.append((f'''backbone.layers.{i}.downsample.norm.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.bias''') )
												rename_keys.append((f'''backbone.norm{i}.weight''', f'''model.pixel_level_module.encoder.hidden_states_norms.{i}.weight''') )
												rename_keys.append((f'''backbone.norm{i}.bias''', f'''model.pixel_level_module.encoder.hidden_states_norms.{i}.bias''') )

						# FPN
						rename_keys.append(("sem_seg_head.layer_4.weight", "model.pixel_level_module.decoder.fpn.stem.0.weight") )
						rename_keys.append(("sem_seg_head.layer_4.norm.weight", "model.pixel_level_module.decoder.fpn.stem.1.weight") )
						rename_keys.append(("sem_seg_head.layer_4.norm.bias", "model.pixel_level_module.decoder.fpn.stem.1.bias") )
						for source_index, target_index in zip(range(3     ,		0     ,		-1 )     ,		range(0     ,		3 ) ):
												rename_keys.append((f'''sem_seg_head.adapter_{source_index}.weight''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.0.weight''') )
												rename_keys.append((f'''sem_seg_head.adapter_{source_index}.norm.weight''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.weight''') )
												rename_keys.append((f'''sem_seg_head.adapter_{source_index}.norm.bias''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.bias''') )
												rename_keys.append((f'''sem_seg_head.layer_{source_index}.weight''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.block.0.weight''') )
												rename_keys.append((f'''sem_seg_head.layer_{source_index}.norm.weight''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.weight''') )
												rename_keys.append((f'''sem_seg_head.layer_{source_index}.norm.bias''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.bias''') )
						rename_keys.append(("sem_seg_head.mask_features.weight", "model.pixel_level_module.decoder.mask_projection.weight") )
						rename_keys.append(("sem_seg_head.mask_features.bias", "model.pixel_level_module.decoder.mask_projection.bias") )

						# Transformer decoder
						for idx in range(config.decoder_config.decoder_layers ):
												# self-attention out projection
												rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.weight''', f'''model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.weight''') )
												rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.bias''', f'''model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.bias''') )
												# cross-attention out projection
												rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.weight''', f'''model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.weight''') )
												rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.bias''', f'''model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.bias''') )
												# MLP 1
												rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.weight''', f'''model.transformer_module.decoder.layers.{idx}.fc1.weight''') )
												rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.bias''', f'''model.transformer_module.decoder.layers.{idx}.fc1.bias''') )
												# MLP 2
												rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.weight''', f'''model.transformer_module.decoder.layers.{idx}.fc2.weight''') )
												rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.bias''', f'''model.transformer_module.decoder.layers.{idx}.fc2.bias''') )
												# layernorm 1 (self-attention layernorm)
												rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.weight''', f'''model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.weight''') )
												rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.bias''', f'''model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.bias''') )
												# layernorm 2 (cross-attention layernorm)
												rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.weight''', f'''model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.weight''') )
												rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.bias''', f'''model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.bias''') )
												# layernorm 3 (final layernorm)
												rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.weight''', f'''model.transformer_module.decoder.layers.{idx}.final_layer_norm.weight''') )
												rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.bias''', f'''model.transformer_module.decoder.layers.{idx}.final_layer_norm.bias''') )

						rename_keys.append(("sem_seg_head.predictor.transformer.decoder.norm.weight", "model.transformer_module.decoder.layernorm.weight") )
						rename_keys.append(("sem_seg_head.predictor.transformer.decoder.norm.bias", "model.transformer_module.decoder.layernorm.bias") )

						# heads on top
						rename_keys.append(("sem_seg_head.predictor.query_embed.weight", "model.transformer_module.queries_embedder.weight") )

						rename_keys.append(("sem_seg_head.predictor.input_proj.weight", "model.transformer_module.input_projection.weight") )
						rename_keys.append(("sem_seg_head.predictor.input_proj.bias", "model.transformer_module.input_projection.bias") )

						rename_keys.append(("sem_seg_head.predictor.class_embed.weight", "class_predictor.weight") )
						rename_keys.append(("sem_seg_head.predictor.class_embed.bias", "class_predictor.bias") )

						for i in range(3 ):
												rename_keys.append((f'''sem_seg_head.predictor.mask_embed.layers.{i}.weight''', f'''mask_embedder.{i}.0.weight''') )
												rename_keys.append((f'''sem_seg_head.predictor.mask_embed.layers.{i}.bias''', f'''mask_embedder.{i}.0.bias''') )
						# fmt: on

						return rename_keys

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							Optional[Any]     ,		lowerCamelCase_:							str     ,		lowerCamelCase_:							Tuple ):
						"""simple docstring"""






						snake_case   :			Dict						    = dct.pop(lowerCamelCase_ )
						snake_case   :			Union[str, Any]						    = val

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							List[Any]     ,		lowerCamelCase_:							Union[str, Any] ):
						"""simple docstring"""






						snake_case   :			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 ) ):
												snake_case   :			Optional[int]						    = 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)
																		snake_case   :			Union[str, Any]						    = state_dict.pop(f'''backbone.layers.{i}.blocks.{j}.attn.qkv.weight''' )
																		snake_case   :			List[str]						    = state_dict.pop(f'''backbone.layers.{i}.blocks.{j}.attn.qkv.bias''' )
																		# next, add query, keys and values (in that order) to the state dict
																		snake_case   :			Tuple						    = in_proj_weight[:dim, :]
																		snake_case   :			int						    = in_proj_bias[: dim]
																		snake_case   :			Tuple						    = in_proj_weight[
																		    dim : dim * 2, :
																		]
																		snake_case   :			Tuple						    = in_proj_bias[
																		    dim : dim * 2
																		]
																		snake_case   :			int						    = in_proj_weight[
																		    -dim :, :
																		]
																		snake_case   :			Dict						    = in_proj_bias[-dim :]
																		# fmt: on

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							Tuple     ,		lowerCamelCase_:							Optional[int] ):
						"""simple docstring"""






						snake_case   :			List[Any]						    = config.decoder_config.hidden_size
						for idx in range(config.decoder_config.decoder_layers ):
												# read in weights + bias of self-attention input projection layer (in the original implementation, this is a single matrix + bias)
												snake_case   :			int						    = state_dict.pop(f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_weight''' )
												snake_case   :			str						    = state_dict.pop(f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_bias''' )
												# next, add query, keys and values (in that order) to the state dict
												snake_case   :			int						    = in_proj_weight[: hidden_size, :]
												snake_case   :			Optional[int]						    = in_proj_bias[:config.hidden_size]
												snake_case   :			Dict						    = in_proj_weight[hidden_size : hidden_size * 2, :]
												snake_case   :			List[str]						    = in_proj_bias[hidden_size : hidden_size * 2]
												snake_case   :			List[str]						    = in_proj_weight[-hidden_size :, :]
												snake_case   :			int						    = in_proj_bias[-hidden_size :]
												# read in weights + bias of cross-attention input projection layer (in the original implementation, this is a single matrix + bias)
												snake_case   :			Union[str, Any]						    = state_dict.pop(f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_weight''' )
												snake_case   :			str						    = state_dict.pop(f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_bias''' )
												# next, add query, keys and values (in that order) to the state dict
												snake_case   :			List[str]						    = in_proj_weight[: hidden_size, :]
												snake_case   :			str						    = in_proj_bias[:config.hidden_size]
												snake_case   :			str						    = in_proj_weight[hidden_size : hidden_size * 2, :]
												snake_case   :			List[Any]						    = in_proj_bias[hidden_size : hidden_size * 2]
												snake_case   :			Union[str, Any]						    = in_proj_weight[-hidden_size :, :]
												snake_case   :			List[str]						    = in_proj_bias[-hidden_size :]
						# fmt: on

def  __SCREAMING_SNAKE_CASE		(			):
						"""simple docstring"""






						snake_case   :			str						    = "http://images.cocodataset.org/val2017/000000039769.jpg"
						snake_case   :			Dict						    = Image.open(requests.get(lowerCamelCase_     ,		stream=lowerCamelCase_ ).raw )
						return im

@torch.no_grad()
def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							str     ,		lowerCamelCase_:							str     ,		lowerCamelCase_:							str     ,		lowerCamelCase_:							bool = False ):
						"""simple docstring"""






						snake_case   :			Union[str, Any]						    = get_maskformer_config(lowerCamelCase_ )

						# load original state_dict
						with open(lowerCamelCase_     ,		"rb" ) as f:
												snake_case   :			str						    = pickle.load(lowerCamelCase_ )
						snake_case   :			Optional[int]						    = data["model"]

						# for name, param in state_dict.items():
						#     print(name, param.shape)

						# rename keys
						snake_case   :			List[Any]						    = create_rename_keys(lowerCamelCase_ )
						for src, dest in rename_keys:
												rename_key(lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_ )
						read_in_swin_q_k_v(lowerCamelCase_     ,		config.backbone_config )
						read_in_decoder_q_k_v(lowerCamelCase_     ,		lowerCamelCase_ )

						# update to torch tensors
						for key, value in state_dict.items():
												snake_case   :			Optional[int]						    = torch.from_numpy(lowerCamelCase_ )

						# load 🤗 model
						snake_case   :			Dict						    = MaskFormerForInstanceSegmentation(lowerCamelCase_ )
						model.eval()

						for name, param in model.named_parameters():
												print(lowerCamelCase_     ,		param.shape )

						snake_case    ,			snake_case   :			Any						    = model.load_state_dict(lowerCamelCase_     ,		strict=lowerCamelCase_ )
						assert missing_keys == [
						    "model.pixel_level_module.encoder.model.layernorm.weight",
						    "model.pixel_level_module.encoder.model.layernorm.bias",
						]
						assert len(lowerCamelCase_ ) == 0, f'''Unexpected keys: {unexpected_keys}'''

						# verify results
						snake_case   :			int						    = prepare_img()
						if "vistas" in model_name:
												snake_case   :			Union[str, Any]						    = 6_5
						elif "cityscapes" in model_name:
												snake_case   :			Optional[int]						    = 6_5_5_3_5
						else:
												snake_case   :			Optional[Any]						    = 2_5_5
						snake_case   :			Any						    = True if "ade" in model_name else False
						snake_case   :			int						    = MaskFormerImageProcessor(ignore_index=lowerCamelCase_     ,		reduce_labels=lowerCamelCase_ )

						snake_case   :			str						    = image_processor(lowerCamelCase_     ,		return_tensors="pt" )

						snake_case   :			Dict						    = model(**lowerCamelCase_ )

						print("Logits:"     ,		outputs.class_queries_logits[0, :3, :3] )

						if model_name == "maskformer-swin-tiny-ade":
												snake_case   :			int						    = torch.tensor(
												    [[3.6_3_5_3, -4.4_7_7_0, -2.6_0_6_5], [0.5_0_8_1, -4.2_3_9_4, -3.5_3_4_3], [2.1_9_0_9, -5.0_3_5_3, -1.9_3_2_3]] )
						assert torch.allclose(outputs.class_queries_logits[0, :3, :3]     ,		lowerCamelCase_     ,		atol=1e-4 )
						print("Looks ok!" )

						if pytorch_dump_folder_path is not None:
												print(f'''Saving model and image processor to {pytorch_dump_folder_path}''' )
												Path(lowerCamelCase_ ).mkdir(exist_ok=lowerCamelCase_ )
												model.save_pretrained(lowerCamelCase_ )
												image_processor.save_pretrained(lowerCamelCase_ )

						if push_to_hub:
												print("Pushing model and image processor to the hub..." )
												model.push_to_hub(f'''nielsr/{model_name}''' )
												image_processor.push_to_hub(f'''nielsr/{model_name}''' )


if __name__ == "__main__":
			A		=						argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    '--model_name',
			    default='maskformer-swin-tiny-ade',
			    type=str,
			    help=('Name of the MaskFormer model you\'d like to convert',),
			)
			parser.add_argument(
			    '--checkpoint_path',
			    default='/Users/nielsrogge/Documents/MaskFormer_checkpoints/MaskFormer-Swin-tiny-ADE20k/model.pkl',
			    type=str,
			    help='Path to the original state dict (.pth file).',
			)
			parser.add_argument(
			    '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
			)
			parser.add_argument(
			    '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
			)

			A		=						parser.parse_args()
			convert_maskformer_checkpoint(
			    args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
			)








"""simple docstring"""







from random import randint, random

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							int     ,		lowerCamelCase_:							int     ,		lowerCamelCase_:							int     ,		lowerCamelCase_:							bool = False     ,		lowerCamelCase_:							bool = False     ,		lowerCamelCase_:							int = 5     ,		):
						"""simple docstring"""






						snake_case   :			str						    = [[-1] * number_of_cells]  # Create a highway without any car
						snake_case   :			str						    = 0
						snake_case   :			Any						    = max(lowerCamelCase_     ,		0 )
						while i < number_of_cells:
												snake_case   :			Optional[int]						    = (
												    randint(0     ,		lowerCamelCase_ ) if random_speed else initial_speed
												)  # Place the cars
												i += (
												    randint(1     ,		max_speed * 2 ) if random_frequency else frequency
												)  # Arbitrary number, may need tuning
						return highway

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							list     ,		lowerCamelCase_:							int ):
						"""simple docstring"""






						snake_case   :			Any						    = 0
						snake_case   :			int						    = highway_now[car_index + 1 :]
						for cell in range(len(lowerCamelCase_ ) ):  # May need a better name for this
												if cells[cell] != -1:  # If the cell is not empty then
																		return distance  # we have the distance we wanted
												distance += 1
						# Here if the car is near the end of the highway
						return distance + get_distance(lowerCamelCase_     ,		-1 )

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							list     ,		lowerCamelCase_:							float     ,		lowerCamelCase_:							int ):
						"""simple docstring"""






						snake_case   :			List[str]						    = len(lowerCamelCase_ )
						# Beforce calculations, the highway is empty
						snake_case   :			Dict						    = [-1] * number_of_cells

						for car_index in range(lowerCamelCase_ ):
												if highway_now[car_index] != -1:
																		# Add 1 to the current speed of the car and cap the speed
																		snake_case   :			Tuple						    = min(highway_now[car_index] + 1     ,		lowerCamelCase_ )
																		# Number of empty cell before the next car
																		snake_case   :			int						    = get_distance(lowerCamelCase_     ,		lowerCamelCase_ ) - 1
																		# We can't have the car causing an accident
																		snake_case   :			str						    = min(next_highway[car_index]     ,		lowerCamelCase_ )
																		if random() < probability:
																								# Randomly, a driver will slow down
																								snake_case   :			Optional[Any]						    = max(next_highway[car_index] - 1     ,		0 )
						return next_highway

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							list     ,		lowerCamelCase_:							int     ,		lowerCamelCase_:							float     ,		lowerCamelCase_:							int ):
						"""simple docstring"""






						snake_case   :			Optional[Any]						    = len(highway[0] )

						for i in range(lowerCamelCase_ ):
												snake_case   :			Union[str, Any]						    = update(highway[i]     ,		lowerCamelCase_     ,		lowerCamelCase_ )
												snake_case   :			Optional[int]						    = [-1] * number_of_cells

												for car_index in range(lowerCamelCase_ ):
																		snake_case   :			List[Any]						    = next_speeds_calculated[car_index]
																		if speed != -1:
																								# Change the position based on the speed (with % to create the loop)
																								snake_case   :			Optional[Any]						    = (car_index + speed) % number_of_cells
																								# Commit the change of position
																								snake_case   :			Tuple						    = speed
												highway.append(lowerCamelCase_ )

						return highway


if __name__ == "__main__":
			import doctest

			doctest.testmod()



