





'''simple docstring'''






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 (
    ConditionalDetrConfig,
    ConditionalDetrForObjectDetection,
    ConditionalDetrForSegmentation,
    ConditionalDetrImageProcessor,
)
from transformers.utils import logging


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

# here we list all keys to be renamed (original name on the left, our name on the right)
snake_case_     =	[]
for i in range(6):
     # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
     rename_keys.append(
         (f'''transformer.encoder.layers.{i}.self_attn.out_proj.weight''', f'''encoder.layers.{i}.self_attn.out_proj.weight''')
     )
     rename_keys.append(
         (f'''transformer.encoder.layers.{i}.self_attn.out_proj.bias''', f'''encoder.layers.{i}.self_attn.out_proj.bias''')
     )
     rename_keys.append((f'''transformer.encoder.layers.{i}.linear1.weight''', f'''encoder.layers.{i}.fc1.weight'''))
     rename_keys.append((f'''transformer.encoder.layers.{i}.linear1.bias''', f'''encoder.layers.{i}.fc1.bias'''))
     rename_keys.append((f'''transformer.encoder.layers.{i}.linear2.weight''', f'''encoder.layers.{i}.fc2.weight'''))
     rename_keys.append((f'''transformer.encoder.layers.{i}.linear2.bias''', f'''encoder.layers.{i}.fc2.bias'''))
     rename_keys.append(
         (f'''transformer.encoder.layers.{i}.norm1.weight''', f'''encoder.layers.{i}.self_attn_layer_norm.weight''')
     )
     rename_keys.append((f'''transformer.encoder.layers.{i}.norm1.bias''', f'''encoder.layers.{i}.self_attn_layer_norm.bias'''))
     rename_keys.append((f'''transformer.encoder.layers.{i}.norm2.weight''', f'''encoder.layers.{i}.final_layer_norm.weight'''))
     rename_keys.append((f'''transformer.encoder.layers.{i}.norm2.bias''', f'''encoder.layers.{i}.final_layer_norm.bias'''))
     # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.self_attn.out_proj.weight''', f'''decoder.layers.{i}.self_attn.out_proj.weight''')
     )
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.self_attn.out_proj.bias''', f'''decoder.layers.{i}.self_attn.out_proj.bias''')
     )
     rename_keys.append(
         (
             f'''transformer.decoder.layers.{i}.cross_attn.out_proj.weight''',
             f'''decoder.layers.{i}.encoder_attn.out_proj.weight''',
         )
     )
     rename_keys.append(
         (
             f'''transformer.decoder.layers.{i}.cross_attn.out_proj.bias''',
             f'''decoder.layers.{i}.encoder_attn.out_proj.bias''',
         )
     )
     rename_keys.append((f'''transformer.decoder.layers.{i}.linear1.weight''', f'''decoder.layers.{i}.fc1.weight'''))
     rename_keys.append((f'''transformer.decoder.layers.{i}.linear1.bias''', f'''decoder.layers.{i}.fc1.bias'''))
     rename_keys.append((f'''transformer.decoder.layers.{i}.linear2.weight''', f'''decoder.layers.{i}.fc2.weight'''))
     rename_keys.append((f'''transformer.decoder.layers.{i}.linear2.bias''', f'''decoder.layers.{i}.fc2.bias'''))
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.norm1.weight''', f'''decoder.layers.{i}.self_attn_layer_norm.weight''')
     )
     rename_keys.append((f'''transformer.decoder.layers.{i}.norm1.bias''', f'''decoder.layers.{i}.self_attn_layer_norm.bias'''))
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.norm2.weight''', f'''decoder.layers.{i}.encoder_attn_layer_norm.weight''')
     )
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.norm2.bias''', f'''decoder.layers.{i}.encoder_attn_layer_norm.bias''')
     )
     rename_keys.append((f'''transformer.decoder.layers.{i}.norm3.weight''', f'''decoder.layers.{i}.final_layer_norm.weight'''))
     rename_keys.append((f'''transformer.decoder.layers.{i}.norm3.bias''', f'''decoder.layers.{i}.final_layer_norm.bias'''))

     # q, k, v projections in self/cross-attention in decoder for conditional DETR
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.sa_qcontent_proj.weight''', f'''decoder.layers.{i}.sa_qcontent_proj.weight''')
     )
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.sa_kcontent_proj.weight''', f'''decoder.layers.{i}.sa_kcontent_proj.weight''')
     )
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.sa_qpos_proj.weight''', f'''decoder.layers.{i}.sa_qpos_proj.weight''')
     )
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.sa_kpos_proj.weight''', f'''decoder.layers.{i}.sa_kpos_proj.weight''')
     )
     rename_keys.append((f'''transformer.decoder.layers.{i}.sa_v_proj.weight''', f'''decoder.layers.{i}.sa_v_proj.weight'''))
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.ca_qcontent_proj.weight''', f'''decoder.layers.{i}.ca_qcontent_proj.weight''')
     )
     # rename_keys.append((f"transformer.decoder.layers.{i}.ca_qpos_proj.weight", f"decoder.layers.{i}.ca_qpos_proj.weight"))
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.ca_kcontent_proj.weight''', f'''decoder.layers.{i}.ca_kcontent_proj.weight''')
     )
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.ca_kpos_proj.weight''', f'''decoder.layers.{i}.ca_kpos_proj.weight''')
     )
     rename_keys.append((f'''transformer.decoder.layers.{i}.ca_v_proj.weight''', f'''decoder.layers.{i}.ca_v_proj.weight'''))
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.ca_qpos_sine_proj.weight''', f'''decoder.layers.{i}.ca_qpos_sine_proj.weight''')
     )

     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.sa_qcontent_proj.bias''', f'''decoder.layers.{i}.sa_qcontent_proj.bias''')
     )
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.sa_kcontent_proj.bias''', f'''decoder.layers.{i}.sa_kcontent_proj.bias''')
     )
     rename_keys.append((f'''transformer.decoder.layers.{i}.sa_qpos_proj.bias''', f'''decoder.layers.{i}.sa_qpos_proj.bias'''))
     rename_keys.append((f'''transformer.decoder.layers.{i}.sa_kpos_proj.bias''', f'''decoder.layers.{i}.sa_kpos_proj.bias'''))
     rename_keys.append((f'''transformer.decoder.layers.{i}.sa_v_proj.bias''', f'''decoder.layers.{i}.sa_v_proj.bias'''))
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.ca_qcontent_proj.bias''', f'''decoder.layers.{i}.ca_qcontent_proj.bias''')
     )
     # rename_keys.append((f"transformer.decoder.layers.{i}.ca_qpos_proj.bias", f"decoder.layers.{i}.ca_qpos_proj.bias"))
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.ca_kcontent_proj.bias''', f'''decoder.layers.{i}.ca_kcontent_proj.bias''')
     )
     rename_keys.append((f'''transformer.decoder.layers.{i}.ca_kpos_proj.bias''', f'''decoder.layers.{i}.ca_kpos_proj.bias'''))
     rename_keys.append((f'''transformer.decoder.layers.{i}.ca_v_proj.bias''', f'''decoder.layers.{i}.ca_v_proj.bias'''))
     rename_keys.append(
         (f'''transformer.decoder.layers.{i}.ca_qpos_sine_proj.bias''', f'''decoder.layers.{i}.ca_qpos_sine_proj.bias''')
     )

# convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
# for conditional DETR, also convert reference point head and query scale MLP
rename_keys.extend(
    [
        ("""input_proj.weight""", """input_projection.weight"""),
        ("""input_proj.bias""", """input_projection.bias"""),
        ("""query_embed.weight""", """query_position_embeddings.weight"""),
        ("""transformer.decoder.norm.weight""", """decoder.layernorm.weight"""),
        ("""transformer.decoder.norm.bias""", """decoder.layernorm.bias"""),
        ("""class_embed.weight""", """class_labels_classifier.weight"""),
        ("""class_embed.bias""", """class_labels_classifier.bias"""),
        ("""bbox_embed.layers.0.weight""", """bbox_predictor.layers.0.weight"""),
        ("""bbox_embed.layers.0.bias""", """bbox_predictor.layers.0.bias"""),
        ("""bbox_embed.layers.1.weight""", """bbox_predictor.layers.1.weight"""),
        ("""bbox_embed.layers.1.bias""", """bbox_predictor.layers.1.bias"""),
        ("""bbox_embed.layers.2.weight""", """bbox_predictor.layers.2.weight"""),
        ("""bbox_embed.layers.2.bias""", """bbox_predictor.layers.2.bias"""),
        ("""transformer.decoder.ref_point_head.layers.0.weight""", """decoder.ref_point_head.layers.0.weight"""),
        ("""transformer.decoder.ref_point_head.layers.0.bias""", """decoder.ref_point_head.layers.0.bias"""),
        ("""transformer.decoder.ref_point_head.layers.1.weight""", """decoder.ref_point_head.layers.1.weight"""),
        ("""transformer.decoder.ref_point_head.layers.1.bias""", """decoder.ref_point_head.layers.1.bias"""),
        ("""transformer.decoder.query_scale.layers.0.weight""", """decoder.query_scale.layers.0.weight"""),
        ("""transformer.decoder.query_scale.layers.0.bias""", """decoder.query_scale.layers.0.bias"""),
        ("""transformer.decoder.query_scale.layers.1.weight""", """decoder.query_scale.layers.1.weight"""),
        ("""transformer.decoder.query_scale.layers.1.bias""", """decoder.query_scale.layers.1.bias"""),
        ("""transformer.decoder.layers.0.ca_qpos_proj.weight""", """decoder.layers.0.ca_qpos_proj.weight"""),
        ("""transformer.decoder.layers.0.ca_qpos_proj.bias""", """decoder.layers.0.ca_qpos_proj.bias"""),
    ]
)
def 							_lowerCamelCase(  UpperCamelCase__    : List[Any]    ,       UpperCamelCase__    : List[str]    ,       UpperCamelCase__    : Tuple		)		->  Tuple:
    A       :       Optional[Any]							=						state_dict.pop(UpperCamelCase__		)
    A       :       List[Any]							=						val
def 							_lowerCamelCase(  UpperCamelCase__    : Any		)		->  Tuple:
    A       :       Optional[int]							=						OrderedDict()
    for key, value in state_dict.items():
        if "backbone.0.body" in key:
            A       :       Tuple							=						key.replace('''backbone.0.body'''    ,       '''backbone.conv_encoder.model'''		)
            A       :       Dict							=						value
        else:
            A       :       Dict							=						value

    return new_state_dict
def 							_lowerCamelCase(  UpperCamelCase__    : Tuple    ,       UpperCamelCase__    : Tuple=False		)		->  Tuple:
    A       :       Union[str, Any]							=						''''''
    if is_panoptic:
        A       :       int							=						'''conditional_detr.'''

    # first: transformer encoder
    for i in range(6		):
        # read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
        A       :       Optional[int]							=						state_dict.pop(F'''{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight'''		)
        A       :       int							=						state_dict.pop(F'''{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias'''		)
        # next, add query, keys and values (in that order) to the state dict
        A       :       Dict							=						in_proj_weight[:256, :]
        A       :       Dict							=						in_proj_bias[:256]
        A       :       int							=						in_proj_weight[256:512, :]
        A       :       str							=						in_proj_bias[256:512]
        A       :       Union[str, Any]							=						in_proj_weight[-256:, :]
        A       :       List[str]							=						in_proj_bias[-256:]
def 							_lowerCamelCase(  )		->  List[str]:
    A       :       Union[str, Any]							=						'''http://images.cocodataset.org/val2017/000000039769.jpg'''
    A       :       int							=						Image.open(requests.get(UpperCamelCase__    ,       stream=UpperCamelCase__		).raw		)

    return im
@torch.no_grad()
def 							_lowerCamelCase(  UpperCamelCase__    : List[str]    ,       UpperCamelCase__    : int		)		->  Any:
    A       :       str							=						ConditionalDetrConfig()
    # set backbone and dilation attributes
    if "resnet101" in model_name:
        A       :       Union[str, Any]							=						'''resnet101'''
    if "dc5" in model_name:
        A       :       Tuple							=						True
    A       :       Tuple							=						'''panoptic''' in model_name
    if is_panoptic:
        A       :       Optional[Any]							=						250
    else:
        A       :       List[Any]							=						91
        A       :       Dict							=						'''huggingface/label-files'''
        A       :       Optional[int]							=						'''coco-detection-id2label.json'''
        A       :       Any							=						json.load(open(hf_hub_download(UpperCamelCase__    ,       UpperCamelCase__    ,       repo_type='''dataset'''		)    ,       '''r'''		)		)
        A       :       Optional[Any]							=						{int(UpperCamelCase__		): v for k, v in idalabel.items()}
        A       :       Optional[int]							=						idalabel
        A       :       Union[str, Any]							=						{v: k for k, v in idalabel.items()}

    # load image processor
    A       :       Tuple							=						'''coco_panoptic''' if is_panoptic else '''coco_detection'''
    A       :       List[Any]							=						ConditionalDetrImageProcessor(format=UpperCamelCase__		)

    # prepare image
    A       :       int							=						prepare_img()
    A       :       Dict							=						image_processor(images=UpperCamelCase__    ,       return_tensors='''pt'''		)
    A       :       Tuple							=						encoding['''pixel_values''']

    logger.info(F'''Converting model {model_name}...'''		)

    # load original model from torch hub
    A       :       Tuple							=						torch.hub.load('''DeppMeng/ConditionalDETR'''    ,       UpperCamelCase__    ,       pretrained=UpperCamelCase__		).eval()
    A       :       List[str]							=						conditional_detr.state_dict()
    # rename keys
    for src, dest in rename_keys:
        if is_panoptic:
            A       :       Optional[Any]							=						'''conditional_detr.''' + src
        rename_key(UpperCamelCase__    ,       UpperCamelCase__    ,       UpperCamelCase__		)
    A       :       str							=						rename_backbone_keys(UpperCamelCase__		)
    # query, key and value matrices need special treatment
    read_in_q_k_v(UpperCamelCase__    ,       is_panoptic=UpperCamelCase__		)
    # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
    A       :       Tuple							=						'''conditional_detr.model.''' if is_panoptic else '''model.'''
    for key in state_dict.copy().keys():
        if is_panoptic:
            if (
                key.startswith('''conditional_detr'''		)
                and not key.startswith('''class_labels_classifier'''		)
                and not key.startswith('''bbox_predictor'''		)
            ):
                A       :       Optional[Any]							=						state_dict.pop(UpperCamelCase__		)
                A       :       Optional[Any]							=						val
            elif "class_labels_classifier" in key or "bbox_predictor" in key:
                A       :       Optional[Any]							=						state_dict.pop(UpperCamelCase__		)
                A       :       int							=						val
            elif key.startswith('''bbox_attention'''		) or key.startswith('''mask_head'''		):
                continue
            else:
                A       :       Any							=						state_dict.pop(UpperCamelCase__		)
                A       :       List[str]							=						val
        else:
            if not key.startswith('''class_labels_classifier'''		) and not key.startswith('''bbox_predictor'''		):
                A       :       Optional[Any]							=						state_dict.pop(UpperCamelCase__		)
                A       :       Any							=						val
    # finally, create HuggingFace model and load state dict
    A       :       Tuple							=						ConditionalDetrForSegmentation(UpperCamelCase__		) if is_panoptic else ConditionalDetrForObjectDetection(UpperCamelCase__		)
    model.load_state_dict(UpperCamelCase__		)
    model.eval()
    model.push_to_hub(repo_id=UpperCamelCase__    ,       organization='''DepuMeng'''    ,       commit_message='''Add model'''		)
    # verify our conversion
    A       :       Optional[int]							=						conditional_detr(UpperCamelCase__		)
    A       :       Union[str, Any]							=						model(UpperCamelCase__		)
    assert torch.allclose(outputs.logits    ,       original_outputs['''pred_logits''']    ,       atol=1e-4		)
    assert torch.allclose(outputs.pred_boxes    ,       original_outputs['''pred_boxes''']    ,       atol=1e-4		)
    if is_panoptic:
        assert torch.allclose(outputs.pred_masks    ,       original_outputs['''pred_masks''']    ,       atol=1e-4		)

    # Save model and image processor
    logger.info(F'''Saving PyTorch model and image processor to {pytorch_dump_folder_path}...'''		)
    Path(UpperCamelCase__		).mkdir(exist_ok=UpperCamelCase__		)
    model.save_pretrained(UpperCamelCase__		)
    image_processor.save_pretrained(UpperCamelCase__		)


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

     parser.add_argument(
         """--model_name""",
         default="""conditional_detr_resnet50""",
         type=str,
         help="""Name of the CONDITIONAL_DETR 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."""
     )
     snake_case_     =	parser.parse_args()
     convert_conditional_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path)







'''simple docstring'''






snake_case_     =	[
    9_99,
    8_00,
    7_99,
    6_00,
    5_99,
    5_00,
    4_00,
    3_99,
    3_77,
    3_55,
    3_33,
    3_11,
    2_88,
    2_66,
    2_44,
    2_22,
    2_00,
    1_99,
    1_77,
    1_55,
    1_33,
    1_11,
    88,
    66,
    44,
    22,
    0,
]

snake_case_     =	[
    9_99,
    9_76,
    9_52,
    9_28,
    9_05,
    8_82,
    8_58,
    8_57,
    8_10,
    7_62,
    7_15,
    7_14,
    5_72,
    4_29,
    4_28,
    2_86,
    2_85,
    2_38,
    1_90,
    1_43,
    1_42,
    1_18,
    95,
    71,
    47,
    24,
    0,
]

snake_case_     =	[
    9_99,
    9_88,
    9_77,
    9_66,
    9_55,
    9_44,
    9_33,
    9_22,
    9_11,
    9_00,
    8_99,
    8_79,
    8_59,
    8_40,
    8_20,
    8_00,
    7_99,
    7_66,
    7_33,
    7_00,
    6_99,
    6_50,
    6_00,
    5_99,
    5_00,
    4_99,
    4_00,
    3_99,
    3_50,
    3_00,
    2_99,
    2_66,
    2_33,
    2_00,
    1_99,
    1_79,
    1_59,
    1_40,
    1_20,
    1_00,
    99,
    88,
    77,
    66,
    55,
    44,
    33,
    22,
    11,
    0,
]

snake_case_     =	[
    9_99,
    9_95,
    9_92,
    9_89,
    9_85,
    9_81,
    9_78,
    9_75,
    9_71,
    9_67,
    9_64,
    9_61,
    9_57,
    9_56,
    9_51,
    9_47,
    9_42,
    9_37,
    9_33,
    9_28,
    9_23,
    9_19,
    9_14,
    9_13,
    9_08,
    9_03,
    8_97,
    8_92,
    8_87,
    8_81,
    8_76,
    8_71,
    8_70,
    8_64,
    8_58,
    8_52,
    8_46,
    8_40,
    8_34,
    8_28,
    8_27,
    8_20,
    8_13,
    8_06,
    7_99,
    7_92,
    7_85,
    7_84,
    7_77,
    7_70,
    7_63,
    7_56,
    7_49,
    7_42,
    7_41,
    7_33,
    7_24,
    7_16,
    7_07,
    6_99,
    6_98,
    6_88,
    6_77,
    6_66,
    6_56,
    6_55,
    6_45,
    6_34,
    6_23,
    6_13,
    6_12,
    5_98,
    5_84,
    5_70,
    5_69,
    5_55,
    5_41,
    5_27,
    5_26,
    5_05,
    4_84,
    4_83,
    4_62,
    4_40,
    4_39,
    3_96,
    3_95,
    3_52,
    3_51,
    3_08,
    3_07,
    2_64,
    2_63,
    2_20,
    2_19,
    1_76,
    1_32,
    88,
    44,
    0,
]

snake_case_     =	[
    9_99,
    9_97,
    9_95,
    9_92,
    9_90,
    9_88,
    9_86,
    9_84,
    9_81,
    9_79,
    9_77,
    9_75,
    9_72,
    9_70,
    9_68,
    9_66,
    9_64,
    9_61,
    9_59,
    9_57,
    9_56,
    9_54,
    9_51,
    9_49,
    9_46,
    9_44,
    9_41,
    9_39,
    9_36,
    9_34,
    9_31,
    9_29,
    9_26,
    9_24,
    9_21,
    9_19,
    9_16,
    9_14,
    9_13,
    9_10,
    9_07,
    9_05,
    9_02,
    8_99,
    8_96,
    8_93,
    8_91,
    8_88,
    8_85,
    8_82,
    8_79,
    8_77,
    8_74,
    8_71,
    8_70,
    8_67,
    8_64,
    8_61,
    8_58,
    8_55,
    8_52,
    8_49,
    8_46,
    8_43,
    8_40,
    8_37,
    8_34,
    8_31,
    8_28,
    8_27,
    8_24,
    8_21,
    8_17,
    8_14,
    8_11,
    8_08,
    8_04,
    8_01,
    7_98,
    7_95,
    7_91,
    7_88,
    7_85,
    7_84,
    7_80,
    7_77,
    7_74,
    7_70,
    7_66,
    7_63,
    7_60,
    7_56,
    7_52,
    7_49,
    7_46,
    7_42,
    7_41,
    7_37,
    7_33,
    7_30,
    7_26,
    7_22,
    7_18,
    7_14,
    7_10,
    7_07,
    7_03,
    6_99,
    6_98,
    6_94,
    6_90,
    6_85,
    6_81,
    6_77,
    6_73,
    6_69,
    6_64,
    6_60,
    6_56,
    6_55,
    6_50,
    6_46,
    6_41,
    6_36,
    6_32,
    6_27,
    6_22,
    6_18,
    6_13,
    6_12,
    6_07,
    6_02,
    5_96,
    5_91,
    5_86,
    5_80,
    5_75,
    5_70,
    5_69,
    5_63,
    5_57,
    5_51,
    5_45,
    5_39,
    5_33,
    5_27,
    5_26,
    5_19,
    5_12,
    5_05,
    4_98,
    4_91,
    4_84,
    4_83,
    4_74,
    4_66,
    4_57,
    4_49,
    4_40,
    4_39,
    4_28,
    4_18,
    4_07,
    3_96,
    3_95,
    3_81,
    3_66,
    3_52,
    3_51,
    3_30,
    3_08,
    3_07,
    2_86,
    2_64,
    2_63,
    2_42,
    2_20,
    2_19,
    1_76,
    1_75,
    1_32,
    1_31,
    88,
    44,
    0,
]

snake_case_     =	[
    9_99,
    9_91,
    9_82,
    9_74,
    9_66,
    9_58,
    9_50,
    9_41,
    9_33,
    9_25,
    9_16,
    9_08,
    9_00,
    8_99,
    8_74,
    8_50,
    8_25,
    8_00,
    7_99,
    7_00,
    6_00,
    5_00,
    4_00,
    3_00,
    2_00,
    1_00,
    0,
]

snake_case_     =	[
    9_99,
    9_92,
    9_85,
    9_78,
    9_71,
    9_64,
    9_57,
    9_49,
    9_42,
    9_35,
    9_28,
    9_21,
    9_14,
    9_07,
    9_00,
    8_99,
    8_79,
    8_59,
    8_40,
    8_20,
    8_00,
    7_99,
    7_66,
    7_33,
    7_00,
    6_99,
    6_50,
    6_00,
    5_99,
    5_00,
    4_99,
    4_00,
    3_99,
    3_00,
    2_99,
    2_00,
    1_99,
    1_00,
    99,
    0,
]

snake_case_     =	[
    9_99,
    9_96,
    9_92,
    9_89,
    9_85,
    9_82,
    9_79,
    9_75,
    9_72,
    9_68,
    9_65,
    9_61,
    9_58,
    9_55,
    9_51,
    9_48,
    9_44,
    9_41,
    9_38,
    9_34,
    9_31,
    9_27,
    9_24,
    9_20,
    9_17,
    9_14,
    9_10,
    9_07,
    9_03,
    9_00,
    8_99,
    8_91,
    8_84,
    8_76,
    8_69,
    8_61,
    8_53,
    8_46,
    8_38,
    8_30,
    8_23,
    8_15,
    8_08,
    8_00,
    7_99,
    7_88,
    7_77,
    7_66,
    7_55,
    7_44,
    7_33,
    7_22,
    7_11,
    7_00,
    6_99,
    6_88,
    6_77,
    6_66,
    6_55,
    6_44,
    6_33,
    6_22,
    6_11,
    6_00,
    5_99,
    5_85,
    5_71,
    5_57,
    5_42,
    5_28,
    5_14,
    5_00,
    4_99,
    4_85,
    4_71,
    4_57,
    4_42,
    4_28,
    4_14,
    4_00,
    3_99,
    3_79,
    3_59,
    3_40,
    3_20,
    3_00,
    2_99,
    2_79,
    2_59,
    2_40,
    2_20,
    2_00,
    1_99,
    1_66,
    1_33,
    1_00,
    99,
    66,
    33,
    0,
]
