


"""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 DetrConfig, DetrForObjectDetection, DetrForSegmentation, DetrImageProcessor
from transformers.utils import logging


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

# here we list all keys to be renamed (original name on the left, our name on the right)
a_											=     []
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}.multihead_attn.out_proj.weight''',
		        f'''decoder.layers.{i}.encoder_attn.out_proj.weight''',
		    )
		)
		rename_keys.append(
		    (
		        f'''transformer.decoder.layers.{i}.multihead_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'''))

# convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
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"),
    ]
)






def   a__			(					__lowercase  ,      __lowercase  ,      __lowercase )						->						int:
				_A       	=      state_dict.pop(__lowercase )
				_A       	=      val






def   a__			(					__lowercase )						->						Optional[Any]:
				_A       	=      OrderedDict()
				for key, value in state_dict.items():
								if "backbone.0.body" in key:
												_A       	=      key.replace("backbone.0.body"  ,      "backbone.conv_encoder.model" )
												_A       	=      value
								else:
												_A       	=      value

				return new_state_dict






def   a__			(					__lowercase  ,      __lowercase=False )						->						Any:
				_A       	=      ""
				if is_panoptic:
								_A       	=      "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       	=      state_dict.pop(f"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight""" )
								_A       	=      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       	=      in_proj_weight[:256, :]
								_A       	=      in_proj_bias[:256]
								_A       	=      in_proj_weight[256:512, :]
								_A       	=      in_proj_bias[256:512]
								_A       	=      in_proj_weight[-256:, :]
								_A       	=      in_proj_bias[-256:]
				# next: transformer decoder (which is a bit more complex because it also includes cross-attention)
				for i in range(6 ):
								# read in weights + bias of input projection layer of self-attention
								_A       	=      state_dict.pop(f"""{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight""" )
								_A       	=      state_dict.pop(f"""{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias""" )
								# next, add query, keys and values (in that order) to the state dict
								_A       	=      in_proj_weight[:256, :]
								_A       	=      in_proj_bias[:256]
								_A       	=      in_proj_weight[256:512, :]
								_A       	=      in_proj_bias[256:512]
								_A       	=      in_proj_weight[-256:, :]
								_A       	=      in_proj_bias[-256:]
								# read in weights + bias of input projection layer of cross-attention
								_A       	=      state_dict.pop(
								    f"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight""" )
								_A       	=      state_dict.pop(f"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias""" )
								# next, add query, keys and values (in that order) of cross-attention to the state dict
								_A       	=      in_proj_weight_cross_attn[:256, :]
								_A       	=      in_proj_bias_cross_attn[:256]
								_A       	=      in_proj_weight_cross_attn[256:512, :]
								_A       	=      in_proj_bias_cross_attn[256:512]
								_A       	=      in_proj_weight_cross_attn[-256:, :]
								_A       	=      in_proj_bias_cross_attn[-256:]






def   a__			(					)						->						Optional[int]:
				_A       	=      "http://images.cocodataset.org/val2017/000000039769.jpg"
				_A       	=      Image.open(requests.get(__lowercase  ,      stream=__lowercase ).raw )

				return im






@torch.no_grad()
def   a__			(					__lowercase  ,      __lowercase )						->						List[str]:
				_A       	=      DetrConfig()
				# set backbone and dilation attributes
				if "resnet101" in model_name:
								_A       	=      "resnet101"
				if "dc5" in model_name:
								_A       	=      True
				_A       	=      "panoptic" in model_name
				if is_panoptic:
								_A       	=      250
				else:
								_A       	=      91
								_A       	=      "huggingface/label-files"
								_A       	=      "coco-detection-id2label.json"
								_A       	=      json.load(open(hf_hub_download(__lowercase  ,      __lowercase  ,      repo_type="dataset" )  ,      "r" ) )
								_A       	=      {int(__lowercase ): v for k, v in idalabel.items()}
								_A       	=      idalabel
								_A       	=      {v: k for k, v in idalabel.items()}

				# load image processor
				_A       	=      "coco_panoptic" if is_panoptic else "coco_detection"
				_A       	=      DetrImageProcessor(format=__lowercase )

				# prepare image
				_A       	=      prepare_img()
				_A       	=      image_processor(images=__lowercase  ,      return_tensors="pt" )
				_A       	=      encoding["pixel_values"]

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

				# load original model from torch hub
				_A       	=      torch.hub.load("facebookresearch/detr"  ,      __lowercase  ,      pretrained=__lowercase ).eval()
				_A       	=      detr.state_dict()
				# rename keys
				for src, dest in rename_keys:
								if is_panoptic:
												_A       	=      "detr." + src
								rename_key(__lowercase  ,      __lowercase  ,      __lowercase )
				_A       	=      rename_backbone_keys(__lowercase )
				# query, key and value matrices need special treatment
				read_in_q_k_v(__lowercase  ,      is_panoptic=__lowercase )
				# important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
				_A       	=      "detr.model." if is_panoptic else "model."
				for key in state_dict.copy().keys():
								if is_panoptic:
												if (
												    key.startswith("detr" )
												    and not key.startswith("class_labels_classifier" )
												    and not key.startswith("bbox_predictor" )
												):
																_A       	=      state_dict.pop(__lowercase )
																_A       	=      val
												elif "class_labels_classifier" in key or "bbox_predictor" in key:
																_A       	=      state_dict.pop(__lowercase )
																_A       	=      val
												elif key.startswith("bbox_attention" ) or key.startswith("mask_head" ):
																continue
												else:
																_A       	=      state_dict.pop(__lowercase )
																_A       	=      val
								else:
												if not key.startswith("class_labels_classifier" ) and not key.startswith("bbox_predictor" ):
																_A       	=      state_dict.pop(__lowercase )
																_A       	=      val
    # finally, create HuggingFace model and load state dict
				_A       	=      DetrForSegmentation(__lowercase ) if is_panoptic else DetrForObjectDetection(__lowercase )
				model.load_state_dict(__lowercase )
				model.eval()
				# verify our conversion
				_A       	=      detr(__lowercase )
				_A       	=      model(__lowercase )
				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(__lowercase ).mkdir(exist_ok=__lowercase )
				model.save_pretrained(__lowercase )
				image_processor.save_pretrained(__lowercase )


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

		parser.add_argument(
		    "--model_name", default="detr_resnet50", type=str, help="Name of the 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."
		)
		a_											=     parser.parse_args()
		convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path)



"""simple docstring"""


import colorsys
import io

import cva
import matplotlib as mpl
import matplotlib.colors as mplc
import matplotlib.figure as mplfigure
import numpy as np
import torch
from matplotlib.backends.backend_agg import FigureCanvasAgg

from utils import img_tensorize


a_											=     10_00
class snake_case   :







		def __init__(       self   :							Optional[int]     , a__   :							int     , a__   :							List[str]=1.2     , a__   :							int="g"     , a__   :							List[Any]=0.5     , a__   :							Tuple="-"     , a__   :							Optional[int]="test_out.jpg"     , a__   :							Tuple=True     , a__   :							List[str]=False     , a__   :							Dict=None     , a__   :							Optional[Any]=None     , a__   :							Optional[int]=0.7     , )							->    Union[str, Any]:





						'''simple docstring'''







						if isinstance(a__     , torch.Tensor		):
										_A       	=      img.numpy().astype("np.uint8"		)
						if isinstance(a__     , a__		):
										_A       	=      img_tensorize(a__		)
						assert isinstance(a__     , np.ndarray		)

						_A	,		_A       	=      img.shape[1], img.shape[0]
						_A       	=      mplfigure.Figure(frameon=a__		)
						_A       	=      fig.get_dpi()
						_A       	=      (width * scale + 1E-2) / dpi
						_A       	=      (height * scale + 1E-2) / dpi
						fig.set_size_inches(a__     , a__		)
						_A       	=      fig.add_axes([0.0, 0.0, 1.0, 1.0]		)
						ax.axis("off"		)
						ax.set_xlim(0.0     , a__		)
						ax.set_ylim(a__		)

						_A       	=      saveas
						_A       	=      rgb
						_A       	=      pynb
						_A       	=      img
						_A       	=      edgecolor
						_A       	=      0.5
						_A       	=      linestyle
						_A       	=      int(np.sqrt(min(a__     , a__		)		) * scale // 3		)
						_A       	=      width
						_A       	=      height
						_A       	=      scale
						_A       	=      fig
						_A       	=      ax
						_A       	=      pad
						_A       	=      idaobj
						_A       	=      idaattr
						_A       	=      FigureCanvasAgg(a__		)







		def 			a_			(       self   :							List[Any]     , a__   :							Union[str, Any]     , a__   :							Tuple=None		)							->    Tuple:





						'''simple docstring'''







						if color is None:
										_A       	=      self.edgecolor
						((_A)	,		(_A)	,		(_A)	,		(_A))       	=      box
						_A       	=      xa - xa
						_A       	=      ya - ya
						self.ax.add_patch(
						    mpl.patches.Rectangle(
						        (xa, ya)     , a__     , a__     , fill=a__     , edgecolor=a__     , linewidth=self.font_size // 3     , alpha=self.alpha     , linestyle=self.linestyle     , )		)







		def 			a_			(       self   :							Union[str, Any]     , a__   :							Dict     , a__   :							List[Any]=None     , a__   :							int=None     , a__   :							str=None     , a__   :							Optional[int]=None		)							->    List[str]:





						'''simple docstring'''







						if len(boxes.shape		) > 2:
										_A       	=      boxes[0]
						if len(obj_ids.shape		) > 1:
										_A       	=      obj_ids[0]
						if len(obj_scores.shape		) > 1:
										_A       	=      obj_scores[0]
						if len(attr_ids.shape		) > 1:
										_A       	=      attr_ids[0]
						if len(attr_scores.shape		) > 1:
										_A       	=      attr_scores[0]
						if isinstance(a__     , torch.Tensor		):
										_A       	=      boxes.numpy()
						if isinstance(a__     , a__		):
										_A       	=      np.array(a__		)
						assert isinstance(a__     , np.ndarray		)
						_A       	=      np.prod(boxes[:, 2:] - boxes[:, :2]     , axis=1		)
						_A       	=      np.argsort(-areas		).tolist()
						_A       	=      boxes[sorted_idxs] if boxes is not None else None
						_A       	=      obj_ids[sorted_idxs] if obj_ids is not None else None
						_A       	=      obj_scores[sorted_idxs] if obj_scores is not None else None
						_A       	=      attr_ids[sorted_idxs] if attr_ids is not None else None
						_A       	=      attr_scores[sorted_idxs] if attr_scores is not None else None

						_A       	=      [self._random_color(maximum=1		) for _ in range(len(a__		)		)]
						_A       	=      [assigned_colors[idx] for idx in sorted_idxs]
						if obj_ids is not None:
										_A       	=      self._create_text_labels_attr(a__     , a__     , a__     , a__		)
										for i in range(len(a__		)		):
														_A       	=      assigned_colors[i]
														self.add_box(boxes[i]     , a__		)
														self.draw_labels(labels[i]     , boxes[i]     , a__		)







		def 			a_			(       self   :							List[str]     , a__   :							Any     , a__   :							List[str]     , a__   :							Tuple		)							->    int:





						'''simple docstring'''







						_A	,		_A	,		_A	,		_A       	=      box
						_A       	=      (xa, ya)
						_A       	=      (ya - ya) * (xa - xa)
						_A       	=      _SMALL_OBJ * self.scale
						if instance_area < small or ya - ya < 40 * self.scale:
										if ya >= self.height - 5:
														_A       	=      (xa, ya)
										else:
														_A       	=      (xa, ya)

						_A       	=      (ya - ya) / np.sqrt(self.height * self.width		)
						_A       	=      self._change_color_brightness(a__     , brightness_factor=0.7		)
						_A       	=      np.clip((height_ratio - 0.0_2) / 0.0_8 + 1     , 1.2     , 2		)
						font_size *= 0.7_5 * self.font_size

						self.draw_text(
						    text=a__     , position=a__     , color=a__     , )







		def 			a_			(       self   :							str     , a__   :							Optional[int]     , a__   :							Optional[int]     , a__   :							Any="g"     , a__   :							Optional[int]="left"     , )							->    Dict:





						'''simple docstring'''







						_A       	=      0
						_A       	=      self.font_size
						_A       	=      np.maximum(list(mplc.to_rgb(a__		)		)     , 0.2		)
						_A       	=      max(0.8     , np.max(a__		)		)
						_A       	=      {
						    "facecolor": "black",
						    "alpha": self.alpha,
						    "pad": self.pad,
						    "edgecolor": "none",
						}
						_A	,		_A       	=      position
						self.ax.text(
						    a__     , a__     , a__     , size=font_size * self.scale     , family="sans-serif"     , bbox=a__     , verticalalignment="top"     , horizontalalignment=a__     , color=a__     , zorder=10     , rotation=a__     , )







		def 			a_			(       self   :							List[str]     , a__   :							str=None		)							->    Optional[int]:





						'''simple docstring'''







						if saveas is None:
										_A       	=      self.saveas
						if saveas.lower().endswith(".jpg"		) or saveas.lower().endswith(".png"		):
										cva.imwrite(
										    a__     , self._get_buffer()[:, :, ::-1]     , )
						else:
										self.fig.savefig(a__		)







		def 			a_			(       self   :							Union[str, Any]     , a__   :							Optional[Any]     , a__   :							List[Any]     , a__   :							Tuple     , a__   :							List[str]		)							->    Optional[int]:





						'''simple docstring'''







						_A       	=      [self.idaobj[i] for i in classes]
						_A       	=      [self.idaattr[i] for i in attr_classes]
						_A       	=      [
						    F"""{label} {score:.2f} {attr} {attr_score:.2f}"""
						    for label, score, attr, attr_score in zip(a__     , a__     , a__     , a__		)
						]
						return labels







		def 			a_			(       self   :							Any     , a__   :							Dict     , a__   :							Tuple		)							->    Dict:





						'''simple docstring'''







						_A       	=      [self.idaobj[i] for i in classes]
						if scores is not None:
										if labels is None:
														_A       	=      ["{:.0f}%".format(s * 1_00		) for s in scores]
										else:
														_A       	=      ["{} {:.0f}%".format(a__     , s * 1_00		) for li, s in zip(a__     , a__		)]
						return labels







		def 			a_			(       self   :							List[Any]     , a__   :							Optional[Any]=2_55		)							->    str:





						'''simple docstring'''







						_A       	=      np.random.randint(0     , len(_COLORS		)		)
						_A       	=      _COLORS[idx] * maximum
						if not self.rgb:
										_A       	=      ret[::-1]
						return ret







		def 			a_			(       self   :							int		)							->    Dict:





						'''simple docstring'''







						if not self.pynb:
										_A	,		_A       	=      self.canvas.print_to_buffer()
										if (width, height) != (self.width, self.height):
														_A       	=      cva.resize(self.img     , (width, height)		)
										else:
														_A       	=      self.img
						else:
										_A       	=      io.BytesIO()  # works for cairo backend
										self.canvas.print_rgba(a__		)
										_A	,		_A       	=      self.width, self.height
										_A       	=      buf.getvalue()
										_A       	=      self.img

						_A       	=      np.frombuffer(a__     , dtype="uint8"		)
						_A       	=      buffer.reshape(a__     , a__     , 4		)
						_A	,		_A       	=      np.split(a__     , [3]     , axis=2		)

						try:
										import numexpr as ne  # fuse them with numexpr

										_A       	=      ne.evaluate("img * (1 - alpha / 255.0) + rgb * (alpha / 255.0)"		)
						except ImportError:
										_A       	=      alpha.astype("float32"		) / 2_5_5.0
										_A       	=      img * (1 - alpha) + rgb * alpha

						return visualized_image.astype("uint8"		)







		def 			a_			(       self   :							Optional[int]     , a__   :							str     , a__   :							Union[str, Any]		)							->    str:





						'''simple docstring'''







						assert brightness_factor >= -1.0 and brightness_factor <= 1.0
						_A       	=      mplc.to_rgb(a__		)
						_A       	=      colorsys.rgb_to_hls(*mplc.to_rgb(a__		)		)
						_A       	=      polygon_color[1] + (brightness_factor * polygon_color[1])
						_A       	=      0.0 if modified_lightness < 0.0 else modified_lightness
						_A       	=      1.0 if modified_lightness > 1.0 else modified_lightness
						_A       	=      colorsys.hls_to_rgb(polygon_color[0]     , a__     , polygon_color[2]		)
						return modified_color





a_											=     (
    np.array(
        [
            0.0_00,
            0.4_47,
            0.7_41,
            0.8_50,
            0.3_25,
            0.0_98,
            0.9_29,
            0.6_94,
            0.1_25,
            0.4_94,
            0.1_84,
            0.5_56,
            0.4_66,
            0.6_74,
            0.1_88,
            0.3_01,
            0.7_45,
            0.9_33,
            0.6_35,
            0.0_78,
            0.1_84,
            0.3_00,
            0.3_00,
            0.3_00,
            0.6_00,
            0.6_00,
            0.6_00,
            1.0_00,
            0.0_00,
            0.0_00,
            1.0_00,
            0.5_00,
            0.0_00,
            0.7_49,
            0.7_49,
            0.0_00,
            0.0_00,
            1.0_00,
            0.0_00,
            0.0_00,
            0.0_00,
            1.0_00,
            0.6_67,
            0.0_00,
            1.0_00,
            0.3_33,
            0.3_33,
            0.0_00,
            0.3_33,
            0.6_67,
            0.0_00,
            0.3_33,
            1.0_00,
            0.0_00,
            0.6_67,
            0.3_33,
            0.0_00,
            0.6_67,
            0.6_67,
            0.0_00,
            0.6_67,
            1.0_00,
            0.0_00,
            1.0_00,
            0.3_33,
            0.0_00,
            1.0_00,
            0.6_67,
            0.0_00,
            1.0_00,
            1.0_00,
            0.0_00,
            0.0_00,
            0.3_33,
            0.5_00,
            0.0_00,
            0.6_67,
            0.5_00,
            0.0_00,
            1.0_00,
            0.5_00,
            0.3_33,
            0.0_00,
            0.5_00,
            0.3_33,
            0.3_33,
            0.5_00,
            0.3_33,
            0.6_67,
            0.5_00,
            0.3_33,
            1.0_00,
            0.5_00,
            0.6_67,
            0.0_00,
            0.5_00,
            0.6_67,
            0.3_33,
            0.5_00,
            0.6_67,
            0.6_67,
            0.5_00,
            0.6_67,
            1.0_00,
            0.5_00,
            1.0_00,
            0.0_00,
            0.5_00,
            1.0_00,
            0.3_33,
            0.5_00,
            1.0_00,
            0.6_67,
            0.5_00,
            1.0_00,
            1.0_00,
            0.5_00,
            0.0_00,
            0.3_33,
            1.0_00,
            0.0_00,
            0.6_67,
            1.0_00,
            0.0_00,
            1.0_00,
            1.0_00,
            0.3_33,
            0.0_00,
            1.0_00,
            0.3_33,
            0.3_33,
            1.0_00,
            0.3_33,
            0.6_67,
            1.0_00,
            0.3_33,
            1.0_00,
            1.0_00,
            0.6_67,
            0.0_00,
            1.0_00,
            0.6_67,
            0.3_33,
            1.0_00,
            0.6_67,
            0.6_67,
            1.0_00,
            0.6_67,
            1.0_00,
            1.0_00,
            1.0_00,
            0.0_00,
            1.0_00,
            1.0_00,
            0.3_33,
            1.0_00,
            1.0_00,
            0.6_67,
            1.0_00,
            0.3_33,
            0.0_00,
            0.0_00,
            0.5_00,
            0.0_00,
            0.0_00,
            0.6_67,
            0.0_00,
            0.0_00,
            0.8_33,
            0.0_00,
            0.0_00,
            1.0_00,
            0.0_00,
            0.0_00,
            0.0_00,
            0.1_67,
            0.0_00,
            0.0_00,
            0.3_33,
            0.0_00,
            0.0_00,
            0.5_00,
            0.0_00,
            0.0_00,
            0.6_67,
            0.0_00,
            0.0_00,
            0.8_33,
            0.0_00,
            0.0_00,
            1.0_00,
            0.0_00,
            0.0_00,
            0.0_00,
            0.1_67,
            0.0_00,
            0.0_00,
            0.3_33,
            0.0_00,
            0.0_00,
            0.5_00,
            0.0_00,
            0.0_00,
            0.6_67,
            0.0_00,
            0.0_00,
            0.8_33,
            0.0_00,
            0.0_00,
            1.0_00,
            0.0_00,
            0.0_00,
            0.0_00,
            0.1_43,
            0.1_43,
            0.1_43,
            0.8_57,
            0.8_57,
            0.8_57,
            1.0_00,
            1.0_00,
            1.0_00,
        ]
    )
    .astype(np.floataa)
    .reshape(-1, 3)
)