

import argparse

import torch

from diffusers import UNetaDConditionModel
def       UpperCamelCase					(			_lowerCAmelCase     :						List[Any],  _lowerCAmelCase     :						int,  _lowerCAmelCase     :						Union[str, Any],  _lowerCAmelCase     :						str=None,  _lowerCAmelCase     :						int=None,  _lowerCAmelCase     :						int=None )				->			int:
	assert isinstance(_lowerCAmelCase,  _lowerCAmelCase ), "Paths should be a list of dicts containing 'old' and 'new' keys."

	# Splits the attention layers into three variables.
	if attention_paths_to_split is not None:
		for path, path_map in attention_paths_to_split.items():
			_UpperCAmelCase    :							List[Any]									=					old_checkpoint[path]
			_UpperCAmelCase    :							List[Any]									=					old_tensor.shape[0] // 3

			_UpperCAmelCase    :							Optional[Any]									=					(-1, channels) if len(old_tensor.shape ) == 3 else (-1)

			_UpperCAmelCase    :							List[Any]									=					old_tensor.shape[0] // config["""num_head_channels"""] // 3

			_UpperCAmelCase    :							List[str]									=					old_tensor.reshape((num_heads, 3 * channels // num_heads) + old_tensor.shape[1:] )
			_UpperCAmelCase    :							Tuple									=					old_tensor.split(channels // num_heads,  dim=1 )

			_UpperCAmelCase    :							Tuple									=					query.reshape(_lowerCAmelCase )
			_UpperCAmelCase    :							Tuple									=					key.reshape(_lowerCAmelCase )
			_UpperCAmelCase    :							str									=					value.reshape(_lowerCAmelCase )

	for path in paths:
		_UpperCAmelCase    :							Tuple									=					path["""new"""]

		# These have already been assigned
		if attention_paths_to_split is not None and new_path in attention_paths_to_split:
			continue

		if additional_replacements is not None:
			for replacement in additional_replacements:
				_UpperCAmelCase    :							Any									=					new_path.replace(replacement["""old"""],  replacement["""new"""] )

        # proj_attn.weight has to be converted from conv 1D to linear
		_UpperCAmelCase    :							int									=					old_checkpoint[path["""old"""]]
		_UpperCAmelCase    :							str									=					["""proj_attn.weight"""]
		_UpperCAmelCase    :							int									=					["""proj_out.weight""", """proj_in.weight"""]
		if any(k in new_path for k in names ):
			_UpperCAmelCase    :							Any									=					weight[:, :, 0]
		elif any(k in new_path for k in names_a ) and len(weight.shape ) > 2 and ".attentions." not in new_path:
			_UpperCAmelCase    :							List[Any]									=					weight[:, :, 0]
		else:
			_UpperCAmelCase    :							int									=					weight
def       UpperCamelCase					(			_lowerCAmelCase     :						Tuple,  _lowerCAmelCase     :						Any=0 )				->			List[str]:
	_UpperCAmelCase    :							List[Any]									=					[]
	for old_item in old_list:
		_UpperCAmelCase    :							Union[str, Any]									=					old_item

		#         new_item = new_item.replace('norm.weight', 'group_norm.weight')
		#         new_item = new_item.replace('norm.bias', 'group_norm.bias')

		#         new_item = new_item.replace('proj_out.weight', 'proj_attn.weight')
		#         new_item = new_item.replace('proj_out.bias', 'proj_attn.bias')

		#         new_item = shave_segments(new_item, n_shave_prefix_segments=n_shave_prefix_segments)

		mapping.append({"""old""": old_item, """new""": new_item} )

	return mapping
def       UpperCamelCase					(			_lowerCAmelCase     :						List[str],  _lowerCAmelCase     :						Optional[Any]=1 )				->			str:
	if n_shave_prefix_segments >= 0:
		return ".".join(path.split(""".""" )[n_shave_prefix_segments:] )
	else:
		return ".".join(path.split(""".""" )[:n_shave_prefix_segments] )
def       UpperCamelCase					(			_lowerCAmelCase     :						Optional[Any],  _lowerCAmelCase     :						List[str]=0 )				->			List[str]:
	_UpperCAmelCase    :							Any									=					[]
	for old_item in old_list:
		mapping.append({"""old""": old_item, """new""": old_item} )

	return mapping
def       UpperCamelCase					(			_lowerCAmelCase     :						List[Any],  _lowerCAmelCase     :						List[Any]=0 )				->			Optional[int]:
	_UpperCAmelCase    :							Dict									=					[]
	for old_item in old_list:
		_UpperCAmelCase    :							List[str]									=					old_item.replace("""in_layers.0""",  """norm1""" )
		_UpperCAmelCase    :							Optional[Any]									=					new_item.replace("""in_layers.2""",  """conv1""" )

		_UpperCAmelCase    :							Optional[Any]									=					new_item.replace("""out_layers.0""",  """norm2""" )
		_UpperCAmelCase    :							List[Any]									=					new_item.replace("""out_layers.3""",  """conv2""" )

		_UpperCAmelCase    :							int									=					new_item.replace("""emb_layers.1""",  """time_emb_proj""" )
		_UpperCAmelCase    :							str									=					new_item.replace("""skip_connection""",  """conv_shortcut""" )

		_UpperCAmelCase    :							Optional[int]									=					shave_segments(_lowerCAmelCase,  n_shave_prefix_segments=_lowerCAmelCase )

		if "temopral_conv" not in old_item:
			mapping.append({"""old""": old_item, """new""": new_item} )

	return mapping
def       UpperCamelCase					(			_lowerCAmelCase     :						Any,  _lowerCAmelCase     :						Optional[Any],  _lowerCAmelCase     :						Union[str, Any]=None,  _lowerCAmelCase     :						str=False )				->			Any:
	_UpperCAmelCase    :							List[str]									=					{}
	_UpperCAmelCase    :							str									=					list(checkpoint.keys() )

	_UpperCAmelCase    :							List[str]									=					"""model.diffusion_model."""

	# at least a 100 parameters have to start with `model_ema` in order for the checkpoint to be EMA
	if sum(k.startswith("""model_ema""" ) for k in keys ) > 100 and extract_ema:
		print(f'''Checkpoint {path} has both EMA and non-EMA weights.''' )
		print(
		    """In this conversion only the EMA weights are extracted. If you want to instead extract the non-EMA"""
		    """ weights (useful to continue fine-tuning), please make sure to remove the `--extract_ema` flag.""" )
		for key in keys:
			if key.startswith("""model.diffusion_model""" ):
				_UpperCAmelCase    :							Dict									=					"""model_ema.""" + """""".join(key.split(""".""" )[1:] )
				_UpperCAmelCase    :							Any									=					checkpoint.pop(_lowerCAmelCase )
	else:
		if sum(k.startswith("""model_ema""" ) for k in keys ) > 100:
			print(
			    """In this conversion only the non-EMA weights are extracted. If you want to instead extract the EMA"""
			    """ weights (usually better for inference), please make sure to add the `--extract_ema` flag.""" )

		for key in keys:
			_UpperCAmelCase    :							Optional[Any]									=					checkpoint.pop(_lowerCAmelCase )

	_UpperCAmelCase    :							Union[str, Any]									=					{}

	_UpperCAmelCase    :							Optional[int]									=					unet_state_dict["""time_embed.0.weight"""]
	_UpperCAmelCase    :							Optional[int]									=					unet_state_dict["""time_embed.0.bias"""]
	_UpperCAmelCase    :							Tuple									=					unet_state_dict["""time_embed.2.weight"""]
	_UpperCAmelCase    :							List[Any]									=					unet_state_dict["""time_embed.2.bias"""]

	if config["class_embed_type"] is None:
		# No parameters to port
		...
	elif config["class_embed_type"] == "timestep" or config["class_embed_type"] == "projection":
		_UpperCAmelCase    :							Dict									=					unet_state_dict["""label_emb.0.0.weight"""]
		_UpperCAmelCase    :							Tuple									=					unet_state_dict["""label_emb.0.0.bias"""]
		_UpperCAmelCase    :							List[str]									=					unet_state_dict["""label_emb.0.2.weight"""]
		_UpperCAmelCase    :							Any									=					unet_state_dict["""label_emb.0.2.bias"""]
	else:
		raise NotImplementedError(f'''Not implemented `class_embed_type`: {config["class_embed_type"]}''' )

	_UpperCAmelCase    :							Any									=					unet_state_dict["""input_blocks.0.0.weight"""]
	_UpperCAmelCase    :							Union[str, Any]									=					unet_state_dict["""input_blocks.0.0.bias"""]

	_UpperCAmelCase    :							Tuple									=					[v for v in unet_state_dict if v.startswith("""input_blocks.0.1""" )]
	_UpperCAmelCase    :							str									=					renew_attention_paths(_lowerCAmelCase )
	_UpperCAmelCase    :							Dict									=					{"""old""": """input_blocks.0.1""", """new""": """transformer_in"""}
	assign_to_checkpoint(_lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase,  additional_replacements=[meta_path],  config=_lowerCAmelCase )

	_UpperCAmelCase    :							Optional[Any]									=					unet_state_dict["""out.0.weight"""]
	_UpperCAmelCase    :							Optional[int]									=					unet_state_dict["""out.0.bias"""]
	_UpperCAmelCase    :							List[Any]									=					unet_state_dict["""out.2.weight"""]
	_UpperCAmelCase    :							Any									=					unet_state_dict["""out.2.bias"""]

	# Retrieves the keys for the input blocks only
	_UpperCAmelCase    :							List[Any]									=					len({""".""".join(layer.split(""".""" )[:2] ) for layer in unet_state_dict if """input_blocks""" in layer} )
	_UpperCAmelCase    :							Optional[int]									=					{
	    layer_id: [key for key in unet_state_dict if f'''input_blocks.{layer_id}''' in key]
	    for layer_id in range(_lowerCAmelCase )
	}

	# Retrieves the keys for the middle blocks only
	_UpperCAmelCase    :							Optional[int]									=					len({""".""".join(layer.split(""".""" )[:2] ) for layer in unet_state_dict if """middle_block""" in layer} )
	_UpperCAmelCase    :							Optional[Any]									=					{
	    layer_id: [key for key in unet_state_dict if f'''middle_block.{layer_id}''' in key]
	    for layer_id in range(_lowerCAmelCase )
	}

	# Retrieves the keys for the output blocks only
	_UpperCAmelCase    :							int									=					len({""".""".join(layer.split(""".""" )[:2] ) for layer in unet_state_dict if """output_blocks""" in layer} )
	_UpperCAmelCase    :							Optional[Any]									=					{
	    layer_id: [key for key in unet_state_dict if f'''output_blocks.{layer_id}''' in key]
	    for layer_id in range(_lowerCAmelCase )
	}

	for i in range(1,  _lowerCAmelCase ):
		_UpperCAmelCase    :							List[Any]									=					(i - 1) // (config["""layers_per_block"""] + 1)
		_UpperCAmelCase    :							List[str]									=					(i - 1) % (config["""layers_per_block"""] + 1)

		_UpperCAmelCase    :							List[Any]									=					[
		    key for key in input_blocks[i] if f'''input_blocks.{i}.0''' in key and f'''input_blocks.{i}.0.op''' not in key
		]
		_UpperCAmelCase    :							Tuple									=					[key for key in input_blocks[i] if f'''input_blocks.{i}.1''' in key]
		_UpperCAmelCase    :							Any									=					[key for key in input_blocks[i] if f'''input_blocks.{i}.2''' in key]

		if f'''input_blocks.{i}.op.weight''' in unet_state_dict:
			_UpperCAmelCase    :							Optional[Any]									=					unet_state_dict.pop(
			    f'''input_blocks.{i}.op.weight''' )
			_UpperCAmelCase    :							str									=					unet_state_dict.pop(
			    f'''input_blocks.{i}.op.bias''' )

		_UpperCAmelCase    :							Optional[int]									=					renew_resnet_paths(_lowerCAmelCase )
		_UpperCAmelCase    :							Dict									=					{"""old""": f'''input_blocks.{i}.0''', """new""": f'''down_blocks.{block_id}.resnets.{layer_in_block_id}'''}
		assign_to_checkpoint(
		    _lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase,  additional_replacements=[meta_path],  config=_lowerCAmelCase )

		_UpperCAmelCase    :							Union[str, Any]									=					[key for key in resnets if """temopral_conv""" in key]
		_UpperCAmelCase    :							Union[str, Any]									=					renew_temp_conv_paths(_lowerCAmelCase )
		_UpperCAmelCase    :							int									=					{
		    """old""": f'''input_blocks.{i}.0.temopral_conv''',
		    """new""": f'''down_blocks.{block_id}.temp_convs.{layer_in_block_id}''',
		}
		assign_to_checkpoint(
		    _lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase,  additional_replacements=[meta_path],  config=_lowerCAmelCase )

		if len(_lowerCAmelCase ):
			_UpperCAmelCase    :							Tuple									=					renew_attention_paths(_lowerCAmelCase )
			_UpperCAmelCase    :							Any									=					{"""old""": f'''input_blocks.{i}.1''', """new""": f'''down_blocks.{block_id}.attentions.{layer_in_block_id}'''}
			assign_to_checkpoint(
			    _lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase,  additional_replacements=[meta_path],  config=_lowerCAmelCase )

		if len(_lowerCAmelCase ):
			_UpperCAmelCase    :							List[str]									=					renew_attention_paths(_lowerCAmelCase )
			_UpperCAmelCase    :							Optional[Any]									=					{
			    """old""": f'''input_blocks.{i}.2''',
			    """new""": f'''down_blocks.{block_id}.temp_attentions.{layer_in_block_id}''',
			}
			assign_to_checkpoint(
			    _lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase,  additional_replacements=[meta_path],  config=_lowerCAmelCase )

	_UpperCAmelCase    :							Tuple									=					middle_blocks[0]
	_UpperCAmelCase    :							Tuple									=					[key for key in resnet_a if """temopral_conv""" in key]
	_UpperCAmelCase    :							Dict									=					middle_blocks[1]
	_UpperCAmelCase    :							Dict									=					middle_blocks[2]
	_UpperCAmelCase    :							List[str]									=					middle_blocks[3]
	_UpperCAmelCase    :							int									=					[key for key in resnet_a if """temopral_conv""" in key]

	_UpperCAmelCase    :							str									=					renew_resnet_paths(_lowerCAmelCase )
	_UpperCAmelCase    :							Tuple									=					{"""old""": """middle_block.0""", """new""": """mid_block.resnets.0"""}
	assign_to_checkpoint(
	    _lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase,  config=_lowerCAmelCase,  additional_replacements=[meta_path] )

	_UpperCAmelCase    :							List[Any]									=					renew_temp_conv_paths(_lowerCAmelCase )
	_UpperCAmelCase    :							List[Any]									=					{"""old""": """middle_block.0.temopral_conv""", """new""": """mid_block.temp_convs.0"""}
	assign_to_checkpoint(
	    _lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase,  config=_lowerCAmelCase,  additional_replacements=[meta_path] )

	_UpperCAmelCase    :							List[Any]									=					renew_resnet_paths(_lowerCAmelCase )
	_UpperCAmelCase    :							List[Any]									=					{"""old""": """middle_block.3""", """new""": """mid_block.resnets.1"""}
	assign_to_checkpoint(
	    _lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase,  config=_lowerCAmelCase,  additional_replacements=[meta_path] )

	_UpperCAmelCase    :							Dict									=					renew_temp_conv_paths(_lowerCAmelCase )
	_UpperCAmelCase    :							Any									=					{"""old""": """middle_block.3.temopral_conv""", """new""": """mid_block.temp_convs.1"""}
	assign_to_checkpoint(
	    _lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase,  config=_lowerCAmelCase,  additional_replacements=[meta_path] )

	_UpperCAmelCase    :							Optional[int]									=					renew_attention_paths(_lowerCAmelCase )
	_UpperCAmelCase    :							str									=					{"""old""": """middle_block.1""", """new""": """mid_block.attentions.0"""}
	assign_to_checkpoint(
	    _lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase,  additional_replacements=[meta_path],  config=_lowerCAmelCase )

	_UpperCAmelCase    :							int									=					renew_attention_paths(_lowerCAmelCase )
	_UpperCAmelCase    :							List[str]									=					{"""old""": """middle_block.2""", """new""": """mid_block.temp_attentions.0"""}
	assign_to_checkpoint(
	    _lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase,  additional_replacements=[meta_path],  config=_lowerCAmelCase )

	for i in range(_lowerCAmelCase ):
		_UpperCAmelCase    :							Dict									=					i // (config["""layers_per_block"""] + 1)
		_UpperCAmelCase    :							Any									=					i % (config["""layers_per_block"""] + 1)
		_UpperCAmelCase    :							str									=					[shave_segments(_lowerCAmelCase,  2 ) for name in output_blocks[i]]
		_UpperCAmelCase    :							List[str]									=					{}

		for layer in output_block_layers:
			_UpperCAmelCase    :							Union[str, Any]									=					layer.split(""".""" )[0], shave_segments(_lowerCAmelCase,  1 )
			if layer_id in output_block_list:
				output_block_list[layer_id].append(_lowerCAmelCase )
			else:
				_UpperCAmelCase    :							List[Any]									=					[layer_name]

		if len(_lowerCAmelCase ) > 1:
			_UpperCAmelCase    :							List[str]									=					[key for key in output_blocks[i] if f'''output_blocks.{i}.0''' in key]
			_UpperCAmelCase    :							Union[str, Any]									=					[key for key in output_blocks[i] if f'''output_blocks.{i}.1''' in key]
			_UpperCAmelCase    :							List[str]									=					[key for key in output_blocks[i] if f'''output_blocks.{i}.2''' in key]

			_UpperCAmelCase    :							Union[str, Any]									=					renew_resnet_paths(_lowerCAmelCase )
			_UpperCAmelCase    :							int									=					renew_resnet_paths(_lowerCAmelCase )

			_UpperCAmelCase    :							Dict									=					{"""old""": f'''output_blocks.{i}.0''', """new""": f'''up_blocks.{block_id}.resnets.{layer_in_block_id}'''}
			assign_to_checkpoint(
			    _lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase,  additional_replacements=[meta_path],  config=_lowerCAmelCase )

			_UpperCAmelCase    :							Any									=					[key for key in resnets if """temopral_conv""" in key]
			_UpperCAmelCase    :							Dict									=					renew_temp_conv_paths(_lowerCAmelCase )
			_UpperCAmelCase    :							Tuple									=					{
			    """old""": f'''output_blocks.{i}.0.temopral_conv''',
			    """new""": f'''up_blocks.{block_id}.temp_convs.{layer_in_block_id}''',
			}
			assign_to_checkpoint(
			    _lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase,  additional_replacements=[meta_path],  config=_lowerCAmelCase )

			_UpperCAmelCase    :							str									=					{k: sorted(_lowerCAmelCase ) for k, v in output_block_list.items()}
			if ["conv.bias", "conv.weight"] in output_block_list.values():
				_UpperCAmelCase    :							str									=					list(output_block_list.values() ).index(["""conv.bias""", """conv.weight"""] )
				_UpperCAmelCase    :							Union[str, Any]									=					unet_state_dict[
				    f'''output_blocks.{i}.{index}.conv.weight'''
				]
				_UpperCAmelCase    :							str									=					unet_state_dict[
				    f'''output_blocks.{i}.{index}.conv.bias'''
				]

				# Clear attentions as they have been attributed above.
				if len(_lowerCAmelCase ) == 2:
					_UpperCAmelCase    :							Dict									=					[]

			if len(_lowerCAmelCase ):
				_UpperCAmelCase    :							int									=					renew_attention_paths(_lowerCAmelCase )
				_UpperCAmelCase    :							List[Any]									=					{
				    """old""": f'''output_blocks.{i}.1''',
				    """new""": f'''up_blocks.{block_id}.attentions.{layer_in_block_id}''',
				}
				assign_to_checkpoint(
				    _lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase,  additional_replacements=[meta_path],  config=_lowerCAmelCase )

			if len(_lowerCAmelCase ):
				_UpperCAmelCase    :							Dict									=					renew_attention_paths(_lowerCAmelCase )
				_UpperCAmelCase    :							Any									=					{
				    """old""": f'''output_blocks.{i}.2''',
				    """new""": f'''up_blocks.{block_id}.temp_attentions.{layer_in_block_id}''',
				}
				assign_to_checkpoint(
				    _lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase,  additional_replacements=[meta_path],  config=_lowerCAmelCase )
		else:
			_UpperCAmelCase    :							int									=					renew_resnet_paths(_lowerCAmelCase,  n_shave_prefix_segments=1 )
			for path in resnet_0_paths:
				_UpperCAmelCase    :							Optional[int]									=					""".""".join(["""output_blocks""", str(_lowerCAmelCase ), path["""old"""]] )
				_UpperCAmelCase    :							Optional[int]									=					""".""".join(["""up_blocks""", str(_lowerCAmelCase ), """resnets""", str(_lowerCAmelCase ), path["""new"""]] )
				_UpperCAmelCase    :							Union[str, Any]									=					unet_state_dict[old_path]

			_UpperCAmelCase    :							Any									=					[l for l in output_block_layers if """temopral_conv""" in l]
			for path in temopral_conv_paths:
				_UpperCAmelCase    :							Tuple									=					path.split("""temopral_conv.""" )[-1]
				_UpperCAmelCase    :							Any									=					""".""".join(["""output_blocks""", str(_lowerCAmelCase ), str(_lowerCAmelCase ), """temopral_conv""", pruned_path] )
				_UpperCAmelCase    :							List[str]									=					""".""".join(["""up_blocks""", str(_lowerCAmelCase ), """temp_convs""", str(_lowerCAmelCase ), pruned_path] )
				_UpperCAmelCase    :							Any									=					unet_state_dict[old_path]

	return new_checkpoint


if __name__ == "__main__":
						lowerCamelCase__				:  Dict													=  argparse.ArgumentParser()

						parser.add_argument(
						    '''--checkpoint_path''', default=None, type=str, required=True, help='''Path to the checkpoint to convert.'''
						)
						parser.add_argument('''--dump_path''', default=None, type=str, required=True, help='''Path to the output model.''')
						lowerCamelCase__				:  Union[str, Any]													=  parser.parse_args()

						lowerCamelCase__				:  str													=  torch.load(args.checkpoint_path, map_location='''cpu''')
						lowerCamelCase__				:  str													=  UNetaDConditionModel()

						lowerCamelCase__				:  int													=  convert_ldm_unet_checkpoint(unet_checkpoint, unet.config)

						lowerCamelCase__				:  Any													=  set(unet.state_dict().keys()) - set(converted_ckpt.keys())
						lowerCamelCase__				:  Tuple													=  set(converted_ckpt.keys()) - set(unet.state_dict().keys())

						assert len(diff_a) == len(diff_a) == 0, "Converted weights don't match"

						# load state_dict
						unet.load_state_dict(converted_ckpt)

						unet.save_pretrained(args.dump_path)

						# -- finish converting the unet --








"""simple docstring"""






def       UpperCamelCase					(			_lowerCAmelCase     :						int )				->			str:
	_UpperCAmelCase    :							Any									=					1
	_UpperCAmelCase    :							List[str]									=					0
	_UpperCAmelCase    :							str									=					1
	_UpperCAmelCase    :							Union[str, Any]									=					1
	_UpperCAmelCase    :							int									=					3
	_UpperCAmelCase    :							int									=					3
	_UpperCAmelCase    :							List[str]									=					limit
	_UpperCAmelCase    :							Optional[Any]									=					0

	_UpperCAmelCase    :							Any									=					""""""
	while counter != decimal + 1:
		if 4 * q + r - t < n * t:
			result += str(_lowerCAmelCase )
			if counter == 0:
				result += "."

			if decimal == counter:
				break

			counter += 1
			_UpperCAmelCase    :							str									=					10 * (r - n * t)
			_UpperCAmelCase    :							List[Any]									=					((10 * (3 * q + r)) // t) - 10 * n
			q *= 10
			_UpperCAmelCase    :							int									=					nr
		else:
			_UpperCAmelCase    :							Any									=					(2 * q + r) * l
			_UpperCAmelCase    :							str									=					(q * (7 * k) + 2 + (r * l)) // (t * l)
			q *= k
			t *= l
			l += 2
			k += 1
			_UpperCAmelCase    :							List[Any]									=					nn
			_UpperCAmelCase    :							Optional[int]									=					nr
	return result
def       UpperCamelCase					(			)				->			None:
	print(f'''{calculate_pi(50 ) = }''' )
	import doctest

	doctest.testmod()


if __name__ == "__main__":
						main()





