
import argparse
import json
from collections import OrderedDict
from pathlib import Path

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

from transformers import (
    SegformerConfig,
    SegformerForImageClassification,
    SegformerForSemanticSegmentation,
    SegformerImageProcessor,
)
from transformers.utils import logging


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




def   __UpperCamelCase	(							lowerCAmelCase__				:							str    ,  lowerCAmelCase__				:							List[Any]=False    ):
 __a					:    int													=    OrderedDict()
 for key, value in state_dict.items():
  if encoder_only and not key.startswith('''head'''    ):
   __a					:    Tuple													=    '''segformer.encoder.''' + key
  if key.startswith('''backbone'''    ):
   __a					:    str													=    key.replace('''backbone'''    ,  '''segformer.encoder'''    )
  if "patch_embed" in key:
   # replace for example patch_embed1 by patch_embeddings.0
   __a					:    List[str]													=    key[key.find('''patch_embed'''    ) + len('''patch_embed'''    )]
   __a					:    Any													=    key.replace(f"patch_embed{idx}"    ,  f"patch_embeddings.{int(snake_case__    )-1}"    )
  if "norm" in key:
   __a					:    Optional[int]													=    key.replace('''norm'''    ,  '''layer_norm'''    )
  if "segformer.encoder.layer_norm" in key:
   # replace for example layer_norm1 by layer_norm.0
   __a					:    Union[str, Any]													=    key[key.find('''segformer.encoder.layer_norm'''    ) + len('''segformer.encoder.layer_norm'''    )]
   __a					:    Tuple													=    key.replace(f"layer_norm{idx}"    ,  f"layer_norm.{int(snake_case__    )-1}"    )
  if "layer_norm1" in key:
   __a					:    List[Any]													=    key.replace('''layer_norm1'''    ,  '''layer_norm_1'''    )
  if "layer_norm2" in key:
   __a					:    Optional[int]													=    key.replace('''layer_norm2'''    ,  '''layer_norm_2'''    )
  if "block" in key:
   # replace for example block1 by block.0
   __a					:    Optional[int]													=    key[key.find('''block'''    ) + len('''block'''    )]
   __a					:    List[str]													=    key.replace(f"block{idx}"    ,  f"block.{int(snake_case__    )-1}"    )
  if "attn.q" in key:
   __a					:    Union[str, Any]													=    key.replace('''attn.q'''    ,  '''attention.self.query'''    )
  if "attn.proj" in key:
   __a					:    Union[str, Any]													=    key.replace('''attn.proj'''    ,  '''attention.output.dense'''    )
  if "attn" in key:
   __a					:    str													=    key.replace('''attn'''    ,  '''attention.self'''    )
  if "fc1" in key:
   __a					:    int													=    key.replace('''fc1'''    ,  '''dense1'''    )
  if "fc2" in key:
   __a					:    str													=    key.replace('''fc2'''    ,  '''dense2'''    )
  if "linear_pred" in key:
   __a					:    int													=    key.replace('''linear_pred'''    ,  '''classifier'''    )
  if "linear_fuse" in key:
   __a					:    List[str]													=    key.replace('''linear_fuse.conv'''    ,  '''linear_fuse'''    )
   __a					:    Dict													=    key.replace('''linear_fuse.bn'''    ,  '''batch_norm'''    )
  if "linear_c" in key:
   # replace for example linear_c4 by linear_c.3
   __a					:    int													=    key[key.find('''linear_c'''    ) + len('''linear_c'''    )]
   __a					:    List[Any]													=    key.replace(f"linear_c{idx}"    ,  f"linear_c.{int(snake_case__    )-1}"    )
  if key.startswith('''head'''    ):
   __a					:    Tuple													=    key.replace('''head'''    ,  '''classifier'''    )
  __a					:    Optional[int]													=    value

 return new_state_dict




def   __UpperCamelCase	(							lowerCAmelCase__				:							List[Any]    ,  lowerCAmelCase__				:							Union[str, Any]    ):
 # for each of the encoder blocks:
 for i in range(config.num_encoder_blocks    ):
  for j in range(config.depths[i]    ):
   # read in weights + bias of keys and values (which is a single matrix in the original implementation)
   __a					:    Dict													=    state_dict.pop(f"segformer.encoder.block.{i}.{j}.attention.self.kv.weight"    )
   __a					:    int													=    state_dict.pop(f"segformer.encoder.block.{i}.{j}.attention.self.kv.bias"    )
   # next, add keys and values (in that order) to the state dict
   __a					:    Any													=    kv_weight[
       : config.hidden_sizes[i], :
   ]
   __a					:    Tuple													=    kv_bias[: config.hidden_sizes[i]]
   __a					:    Optional[int]													=    kv_weight[
       config.hidden_sizes[i] :, :
   ]
   __a					:    Any													=    kv_bias[
       config.hidden_sizes[i] :
   ]




def   __UpperCamelCase	(							):
 __a					:    List[Any]													=    '''http://images.cocodataset.org/val2017/000000039769.jpg'''
 __a					:    Tuple													=    Image.open(requests.get(snake_case__    ,  stream=snake_case__    ).raw    )

 return image




@torch.no_grad()
def   __UpperCamelCase	(							lowerCAmelCase__				:							Tuple    ,  lowerCAmelCase__				:							Optional[Any]    ,  lowerCAmelCase__				:							Tuple    ):
 __a					:    str													=    SegformerConfig()
 __a					:    Union[str, Any]													=    False

 # set attributes based on model_name
 __a					:    int													=    '''huggingface/label-files'''
 if "segformer" in model_name:
  __a					:    Optional[Any]													=    model_name[len('''segformer.'''    ) : len('''segformer.'''    ) + 2]
  if "ade" in model_name:
   __a					:    Dict													=    1_5_0
   __a					:    int													=    '''ade20k-id2label.json'''
   __a					:    Optional[Any]													=    (1, 1_5_0, 1_2_8, 1_2_8)
  elif "city" in model_name:
   __a					:    int													=    1_9
   __a					:    Tuple													=    '''cityscapes-id2label.json'''
   __a					:    Tuple													=    (1, 1_9, 1_2_8, 1_2_8)
  else:
   raise ValueError(f"Model {model_name} not supported"    )
 elif "mit" in model_name:
  __a					:    Dict													=    True
  __a					:    int													=    model_name[4:6]
  __a					:    Any													=    1_0_0_0
  __a					:    Union[str, Any]													=    '''imagenet-1k-id2label.json'''
  __a					:    Optional[int]													=    (1, 1_0_0_0)
 else:
  raise ValueError(f"Model {model_name} not supported"    )

 # set config attributes
 __a					:    Union[str, Any]													=    json.load(open(hf_hub_download(snake_case__    ,  snake_case__    ,  repo_type='''dataset'''    )    ,  '''r'''    )    )
 __a					:    List[str]													=    {int(snake_case__    ): v for k, v in idalabel.items()}
 __a					:    Union[str, Any]													=    idalabel
 __a					:    str													=    {v: k for k, v in idalabel.items()}
 if size == "b0":
  pass
 elif size == "b1":
  __a					:    int													=    [6_4, 1_2_8, 3_2_0, 5_1_2]
  __a					:    Union[str, Any]													=    2_5_6
 elif size == "b2":
  __a					:    Optional[Any]													=    [6_4, 1_2_8, 3_2_0, 5_1_2]
  __a					:    List[Any]													=    7_6_8
  __a					:    Union[str, Any]													=    [3, 4, 6, 3]
 elif size == "b3":
  __a					:    Any													=    [6_4, 1_2_8, 3_2_0, 5_1_2]
  __a					:    str													=    7_6_8
  __a					:    int													=    [3, 4, 1_8, 3]
 elif size == "b4":
  __a					:    Union[str, Any]													=    [6_4, 1_2_8, 3_2_0, 5_1_2]
  __a					:    Optional[int]													=    7_6_8
  __a					:    str													=    [3, 8, 2_7, 3]
 elif size == "b5":
  __a					:    List[Any]													=    [6_4, 1_2_8, 3_2_0, 5_1_2]
  __a					:    Tuple													=    7_6_8
  __a					:    List[Any]													=    [3, 6, 4_0, 3]
 else:
  raise ValueError(f"Size {size} not supported"    )

 # load image processor (only resize + normalize)
 __a					:    List[Any]													=    SegformerImageProcessor(
     image_scale=(5_1_2, 5_1_2)    ,  keep_ratio=snake_case__    ,  align=snake_case__    ,  do_random_crop=snake_case__    )

 # prepare image
 __a					:    Dict													=    prepare_img()
 __a					:    Optional[Any]													=    image_processor(images=snake_case__    ,  return_tensors='''pt'''    ).pixel_values

 logger.info(f"Converting model {model_name}..."    )

 # load original state dict
 if encoder_only:
  __a					:    Optional[int]													=    torch.load(snake_case__    ,  map_location=torch.device('''cpu'''    )    )
 else:
  __a					:    Tuple													=    torch.load(snake_case__    ,  map_location=torch.device('''cpu'''    )    )['''state_dict''']

 # rename keys
 __a					:    Any													=    rename_keys(snake_case__    ,  encoder_only=snake_case__    )
 if not encoder_only:
  del state_dict["decode_head.conv_seg.weight"]
  del state_dict["decode_head.conv_seg.bias"]

 # key and value matrices need special treatment
 read_in_k_v(snake_case__    ,  snake_case__    )

 # create HuggingFace model and load state dict
 if encoder_only:
  __a					:    Dict													=    False
  __a					:    Any													=    SegformerForImageClassification(snake_case__    )
 else:
  __a					:    List[Any]													=    SegformerForSemanticSegmentation(snake_case__    )
 model.load_state_dict(snake_case__    )
 model.eval()

 # forward pass
 __a					:    int													=    model(snake_case__    )
 __a					:    List[str]													=    outputs.logits

 # set expected_slice based on model name
 # ADE20k checkpoints
 if model_name == "segformer.b0.512x512.ade.160k":
  __a					:    int													=    torch.tensor(
      [
          [[-4.63_10, -5.52_32, -6.23_56], [-5.19_21, -6.14_44, -6.59_96], [-5.44_24, -6.27_90, -6.75_74]],
          [[-12.13_91, -13.31_22, -13.95_54], [-12.87_32, -13.93_52, -14.35_63], [-12.94_38, -13.82_26, -14.25_13]],
          [[-12.51_34, -13.46_86, -14.49_15], [-12.86_69, -14.43_43, -14.77_58], [-13.25_23, -14.58_19, -15.06_94]],
      ]    )
 elif model_name == "segformer.b1.512x512.ade.160k":
  __a					:    Any													=    torch.tensor(
      [
          [[-7.58_20, -8.72_31, -8.32_15], [-8.06_00, -10.35_29, -10.03_04], [-7.52_08, -9.41_03, -9.62_39]],
          [[-12.69_18, -13.89_94, -13.71_37], [-13.31_96, -15.75_23, -15.47_89], [-12.93_43, -14.87_57, -14.96_89]],
          [[-11.19_11, -11.94_21, -11.32_43], [-11.33_42, -13.68_39, -13.35_81], [-10.39_09, -12.18_32, -12.48_58]],
      ]    )
 elif model_name == "segformer.b2.512x512.ade.160k":
  __a					:    str													=    torch.tensor(
      [
          [[-11.81_73, -14.38_50, -16.31_28], [-14.56_48, -16.58_04, -18.65_68], [-14.72_23, -15.73_87, -18.42_18]],
          [[-15.72_90, -17.91_71, -19.44_23], [-18.31_05, -19.94_48, -21.46_61], [-17.92_96, -18.64_97, -20.79_10]],
          [[-15.07_83, -17.03_36, -18.27_89], [-16.87_71, -18.68_70, -20.16_12], [-16.24_54, -17.14_26, -19.50_55]],
      ]    )
 elif model_name == "segformer.b3.512x512.ade.160k":
  __a					:    Any													=    torch.tensor(
      [
          [[-9.08_78, -10.20_81, -10.18_91], [-9.31_44, -10.79_41, -10.98_43], [-9.22_94, -10.38_55, -10.57_04]],
          [[-12.23_16, -13.90_68, -13.61_02], [-12.91_61, -14.37_02, -14.32_35], [-12.52_33, -13.71_74, -13.79_32]],
          [[-14.62_75, -15.24_90, -14.97_27], [-14.34_00, -15.96_87, -16.28_27], [-14.14_84, -15.40_33, -15.89_37]],
      ]    )
 elif model_name == "segformer.b4.512x512.ade.160k":
  __a					:    Union[str, Any]													=    torch.tensor(
      [
          [[-12.31_44, -13.24_47, -14.08_02], [-13.36_14, -14.58_16, -15.61_17], [-13.33_40, -14.44_33, -16.22_19]],
          [[-19.27_81, -20.41_28, -20.75_06], [-20.61_53, -21.65_66, -22.09_98], [-19.98_00, -21.04_30, -22.14_94]],
          [[-18.87_39, -19.78_04, -21.18_34], [-20.12_33, -21.67_65, -23.29_44], [-20.03_15, -21.26_41, -23.69_44]],
      ]    )
 elif model_name == "segformer.b5.640x640.ade.160k":
  __a					:    List[str]													=    torch.tensor(
      [
          [[-9.55_24, -12.08_35, -11.73_48], [-10.52_29, -13.64_46, -14.56_62], [-9.58_42, -12.88_51, -13.94_14]],
          [[-15.34_32, -17.53_23, -17.08_18], [-16.33_30, -18.92_55, -19.21_01], [-15.13_40, -17.78_48, -18.39_71]],
          [[-12.60_72, -14.94_86, -14.66_31], [-13.76_29, -17.09_07, -17.77_45], [-12.78_99, -16.16_95, -17.16_71]],
      ]    )
 # Cityscapes checkpoints
 elif model_name == "segformer.b0.1024x1024.city.160k":
  __a					:    str													=    torch.tensor(
      [
          [[-11.92_95, -13.40_57, -14.81_06], [-13.34_31, -14.81_79, -15.37_81], [-14.28_36, -15.59_42, -16.15_88]],
          [[-11.49_06, -12.80_67, -13.65_64], [-13.11_89, -14.05_00, -14.15_43], [-13.87_48, -14.51_36, -14.87_89]],
          [[0.53_74, 0.10_67, -0.47_42], [0.11_41, -0.22_55, -0.70_99], [-0.30_00, -0.59_24, -1.31_05]],
      ]    )
 elif model_name == "segformer.b0.512x1024.city.160k":
  __a					:    str													=    torch.tensor(
      [
          [[-7.82_17, -9.87_67, -10.17_17], [-9.44_38, -10.90_58, -11.40_47], [-9.79_39, -12.34_95, -12.10_79]],
          [[-7.15_14, -9.53_36, -10.08_60], [-9.77_76, -11.68_22, -11.84_39], [-10.14_11, -12.76_55, -12.89_72]],
          [[0.30_21, 0.08_05, -0.23_10], [-0.03_28, -0.16_05, -0.27_14], [-0.14_08, -0.54_77, -0.69_76]],
      ]    )
 elif model_name == "segformer.b0.640x1280.city.160k":
  __a					:    Union[str, Any]													=    torch.tensor(
      [
          [
              [-1.1372e01, -1.2787e01, -1.3477e01],
              [-1.2536e01, -1.4194e01, -1.4409e01],
              [-1.3217e01, -1.4888e01, -1.5327e01],
          ],
          [
              [-1.4791e01, -1.7122e01, -1.8277e01],
              [-1.7163e01, -1.9192e01, -1.9533e01],
              [-1.7897e01, -1.9991e01, -2.0315e01],
          ],
          [
              [7.6723e-01, 4.1921e-01, -7.7878e-02],
              [4.7772e-01, 9.5557e-03, -2.8082e-01],
              [3.6032e-01, -2.4826e-01, -5.1168e-01],
          ],
      ]    )
 elif model_name == "segformer.b0.768x768.city.160k":
  __a					:    List[str]													=    torch.tensor(
      [
          [[-9.49_59, -11.30_87, -11.74_79], [-11.00_25, -12.65_40, -12.33_19], [-11.40_64, -13.04_87, -12.99_05]],
          [[-9.89_05, -11.30_84, -12.08_54], [-11.17_26, -12.76_98, -12.95_83], [-11.59_85, -13.32_78, -14.17_74]],
          [[0.22_13, 0.01_92, -0.24_66], [-0.17_31, -0.42_13, -0.48_74], [-0.31_26, -0.65_41, -1.13_89]],
      ]    )
 elif model_name == "segformer.b1.1024x1024.city.160k":
  __a					:    str													=    torch.tensor(
      [
          [[-13.57_48, -13.91_11, -12.65_00], [-14.35_00, -15.36_83, -14.23_28], [-14.75_32, -16.04_24, -15.60_87]],
          [[-17.16_51, -15.87_25, -12.96_53], [-17.25_80, -17.37_18, -14.82_23], [-16.60_58, -16.87_83, -16.74_52]],
          [[-3.64_56, -3.02_09, -1.42_03], [-3.07_97, -3.19_59, -2.00_00], [-1.87_57, -1.92_17, -1.69_97]],
      ]    )
 elif model_name == "segformer.b2.1024x1024.city.160k":
  __a					:    List[Any]													=    torch.tensor(
      [
          [[-16.09_76, -16.48_56, -17.39_62], [-16.62_34, -19.03_42, -19.76_85], [-16.09_00, -18.06_61, -19.11_80]],
          [[-18.47_50, -18.84_88, -19.50_74], [-19.40_30, -22.15_70, -22.59_77], [-19.11_91, -20.84_86, -22.37_83]],
          [[-4.51_78, -5.50_37, -6.51_09], [-5.08_84, -7.21_74, -8.03_34], [-4.41_56, -5.81_17, -7.29_70]],
      ]    )
 elif model_name == "segformer.b3.1024x1024.city.160k":
  __a					:    Dict													=    torch.tensor(
      [
          [[-14.20_81, -14.47_32, -14.19_77], [-14.58_67, -16.44_23, -16.63_56], [-13.44_41, -14.96_85, -16.86_96]],
          [[-14.45_76, -14.70_73, -15.04_51], [-15.08_16, -17.62_37, -17.98_73], [-14.42_13, -16.01_99, -18.59_92]],
          [[-4.73_49, -4.95_88, -5.09_66], [-4.32_10, -6.93_25, -7.25_91], [-3.43_12, -4.74_84, -7.19_17]],
      ]    )
 elif model_name == "segformer.b4.1024x1024.city.160k":
  __a					:    str													=    torch.tensor(
      [
          [[-11.77_37, -11.95_26, -11.32_73], [-13.66_92, -14.45_74, -13.88_78], [-13.89_37, -14.69_24, -15.93_45]],
          [[-14.67_06, -14.53_30, -14.13_06], [-16.15_02, -16.81_80, -16.42_69], [-16.83_38, -17.89_39, -20.17_46]],
          [[1.04_91, 0.82_89, 1.03_10], [1.10_44, 0.52_19, 0.80_55], [1.08_99, 0.69_26, 0.55_90]],
      ]    )
 elif model_name == "segformer.b5.1024x1024.city.160k":
  __a					:    int													=    torch.tensor(
      [
          [[-12.56_41, -13.47_77, -13.06_84], [-13.95_87, -15.89_83, -16.65_57], [-13.31_09, -15.73_50, -16.31_41]],
          [[-14.70_74, -15.43_52, -14.59_44], [-16.63_53, -18.16_63, -18.61_20], [-15.17_02, -18.03_29, -18.15_47]],
          [[-1.79_90, -2.09_51, -1.77_84], [-2.63_97, -3.82_45, -3.96_86], [-1.52_64, -2.81_26, -2.93_16]],
      ]    )
 else:
  __a					:    Any													=    logits.argmax(-1    ).item()
  print('''Predicted class:'''    ,  model.config.idalabel[predicted_class_idx]    )

 # verify logits
 if not encoder_only:
  assert logits.shape == expected_shape
  assert torch.allclose(logits[0, :3, :3, :3]    ,  snake_case__    ,  atol=1e-2    )

 # finally, save model and image processor
 logger.info(f"Saving PyTorch model and image processor to {pytorch_dump_folder_path}..."    )
 Path(snake_case__    ).mkdir(exist_ok=snake_case__    )
 model.save_pretrained(snake_case__    )
 image_processor.save_pretrained(snake_case__    )


if __name__ == "__main__":
      lowercase__         =argparse.ArgumentParser()

      parser.add_argument(
          '--model_name',
          default='segformer.b0.512x512.ade.160k',
          type=str,
          help='Name of the model you\'d like to convert.',
      )
      parser.add_argument(
          '--checkpoint_path', default=None, type=str, help='Path to the original PyTorch checkpoint (.pth file).'
      )
      parser.add_argument(
          '--pytorch_dump_folder_path', default=None, type=str, help='Path to the folder to output PyTorch model.'
      )
      lowercase__         =parser.parse_args()
      convert_segformer_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path)


"""simple docstring"""


import copy
import re







class 					lowerCAmelCase_					:



						'''simple docstring'''


						_lowerCamelCase:     str   =     '''hp'''
						_lowerCamelCase:     List[Any]   =     {}
						_lowerCamelCase:     List[Any]   =     None


						@classmethod
						def     _SCREAMING_SNAKE_CASE   (			cls  :   List[Any]	,A_  :   List[str]	,A_  :   Optional[Any]   )  -> Tuple:
							A     = prefix
							A     = defaults
							cls.build_naming_info()


						@staticmethod
						def     _SCREAMING_SNAKE_CASE   (			A_  :   Any	,A_  :   List[Any]   )  -> int:
							if len(A_   ) == 0:
								return ""
							A     = None
							if any(char.isdigit() for char in word   ):
								raise Exception(F'Parameters should not contain numbers: \'{word}\' contains a number'   )
							if word in info["short_word"]:
								return info["short_word"][word]
							for prefix_len in range(1	,len(A_   ) + 1   ):
								A     = word[:prefix_len]
								if prefix in info["reverse_short_word"]:
									continue
								else:
									A     = prefix
									break

							if short_word is None:
								# Paranoid fallback
								def int_to_alphabetic(A_  :   Optional[Any]   ):
									A     = ''
									while integer != 0:
										A     = chr(ord('A'   ) + integer % 10   ) + s
										integer //= 10
									return s

								A     = 0
								while True:
									A     = word + '#' + int_to_alphabetic(A_   )
									if sword in info["reverse_short_word"]:
										continue
									else:
										A     = sword
										break

							A     = short_word
							A     = word
							return short_word


						@staticmethod
						def     _SCREAMING_SNAKE_CASE   (			A_  :   List[Any]	,A_  :   Union[str, Any]   )  -> Union[str, Any]:
							A     = param_name.split('_'   )

							A     = [TrialShortNamer.shortname_for_word(A_	,A_   ) for word in words]

							# We try to create a separatorless short name, but if there is a collision we have to fallback
							# to a separated short name
							A     = ['', '_']

							for separator in separators:
								A     = separator.join(A_   )
								if shortname not in info["reverse_short_param"]:
									A     = shortname
									A     = param_name
									return shortname

							return param_name


						@staticmethod
						def     _SCREAMING_SNAKE_CASE   (			A_  :   List[Any]	,A_  :   Any   )  -> Tuple:
							A     = TrialShortNamer.shortname_for_key(A_	,A_   )
							A     = short_name
							A     = param_name


						@classmethod
						def     _SCREAMING_SNAKE_CASE   (			cls  :   Dict   )  -> List[Any]:
							if cls.NAMING_INFO is not None:
								return

							A     = {
							    'short_word': {},
							    'reverse_short_word': {},
							    'short_param': {},
							    'reverse_short_param': {},
							}

							A     = list(cls.DEFAULTS.keys()   )

							for k in field_keys:
								cls.add_new_param_name(A_	,A_   )

							A     = info


						@classmethod
						def     _SCREAMING_SNAKE_CASE   (			cls  :   List[Any]	,A_  :   Union[str, Any]   )  -> Union[str, Any]:
							cls.build_naming_info()
							assert cls.PREFIX is not None
							A     = [copy.copy(cls.PREFIX   )]

							for k, v in params.items():
								if k not in cls.DEFAULTS:
									raise Exception(F'You should provide a default value for the param name {k} with value {v}'   )
								if v == cls.DEFAULTS[k]:
									# The default value is not added to the name
									continue

								A     = cls.NAMING_INFO['short_param'][k]

								if isinstance(A_	,A_   ):
									A     = 1 if v else 0

								A     = '' if isinstance(A_	,(int, float)   ) else '-'
								A     = F'{key}{sep}{v}'
								name.append(A_   )

							return "_".join(A_   )




						@classmethod
						def     _SCREAMING_SNAKE_CASE   (			cls  :   List[str]	,A_  :   Any   )  -> int:
							A     = repr[len(cls.PREFIX   ) + 1 :]
							if repr == "":
								A     = []
							else:
								A     = repr.split('_'   )

							A     = {}

							for value in values:
								if "-" in value:
									A ,   A     = value.split('-'   )
								else:
									A     = re.sub('[0-9.]'	,''	,A_   )
									A     = float(re.sub('[^0-9.]'	,''	,A_   )   )

								A     = cls.NAMING_INFO['reverse_short_param'][p_k]

								A     = p_v

							for k in cls.DEFAULTS:
								if k not in parameters:
									A     = cls.DEFAULTS[k]

							return parameters