






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 :    str								=				1000


class  __lowercase :







     '''simple docstring'''




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


         """simple docstring"""



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

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

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




     def 						lowerCAmelCase_       (			self    :     Optional[Any]	,		UpperCamelCase_    :     List[Any]	,		UpperCamelCase_    :     Dict=None			):


         """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)	,		UpperCamelCase_	,		UpperCamelCase_	,		fill=UpperCamelCase_	,		edgecolor=UpperCamelCase_	,		linewidth=self.font_size // 3	,		alpha=self.alpha	,		linestyle=self.linestyle	,		)			)




     def 						lowerCAmelCase_       (			self    :     List[Any]	,		UpperCamelCase_    :     List[str]	,		UpperCamelCase_    :     List[str]=None	,		UpperCamelCase_    :     str=None	,		UpperCamelCase_    :     str=None	,		UpperCamelCase_    :     List[str]=None			):


         """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(UpperCamelCase_	,		torch.Tensor			):
             __A             =		boxes.numpy()
         if isinstance(UpperCamelCase_	,		UpperCamelCase_			):
             __A             =		np.array(UpperCamelCase_			)
         assert isinstance(UpperCamelCase_	,		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(UpperCamelCase_			)			)]
         __A             =		[assigned_colors[idx] for idx in sorted_idxs]
         if obj_ids is not None:
             __A             =		self._create_text_labels_attr(UpperCamelCase_	,		UpperCamelCase_	,		UpperCamelCase_	,		UpperCamelCase_			)
             for i in range(len(UpperCamelCase_			)			):
                 __A             =		assigned_colors[i]
                 self.add_box(boxes[i]	,		UpperCamelCase_			)
                 self.draw_labels(labels[i]	,		boxes[i]	,		UpperCamelCase_			)




     def 						lowerCAmelCase_       (			self    :     Dict	,		UpperCamelCase_    :     Any	,		UpperCamelCase_    :     Any	,		UpperCamelCase_    :     List[Any]			):


         """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(UpperCamelCase_	,		brightness_factor=0.7			)
         __A             =		np.clip((height_ratio - 0.02) / 0.08 + 1	,		1.2	,		2			)
         font_size *= 0.75 * self.font_size

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




     def 						lowerCAmelCase_       (			self    :     int	,		UpperCamelCase_    :     List[Any]	,		UpperCamelCase_    :     Any	,		UpperCamelCase_    :     Tuple="g"	,		UpperCamelCase_    :     Tuple="left"	,		):


         """simple docstring"""



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




     def 						lowerCAmelCase_       (			self    :     str	,		UpperCamelCase_    :     Any=None			):


         """simple docstring"""



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




     def 						lowerCAmelCase_       (			self    :     Optional[int]	,		UpperCamelCase_    :     Optional[int]	,		UpperCamelCase_    :     Any	,		UpperCamelCase_    :     str	,		UpperCamelCase_    :     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(UpperCamelCase_	,		UpperCamelCase_	,		UpperCamelCase_	,		UpperCamelCase_			)
         ]
         return labels




     def 						lowerCAmelCase_       (			self    :     Optional[int]	,		UpperCamelCase_    :     Optional[int]	,		UpperCamelCase_    :     Any			):


         """simple docstring"""



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




     def 						lowerCAmelCase_       (			self    :     Dict	,		UpperCamelCase_    :     Any=255			):


         """simple docstring"""



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




     def 						lowerCAmelCase_       (			self    :     str			):


         """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(UpperCamelCase_			)
             __A      ,		__A             =		self.width, self.height
             __A             =		buf.getvalue()
             __A             =		self.img

         __A             =		np.frombuffer(UpperCamelCase_	,		dtype="""uint8"""			)
         __A             =		buffer.reshape(UpperCamelCase_	,		UpperCamelCase_	,		4			)
         __A      ,		__A             =		np.split(UpperCamelCase_	,		[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"""			) / 255.0
             __A             =		img * (1 - alpha) + rgb * alpha

         return visualized_image.astype("""uint8"""			)





     def 						lowerCAmelCase_       (			self    :     str	,		UpperCamelCase_    :     Union[str, Any]	,		UpperCamelCase_    :     Union[str, Any]			):


         """simple docstring"""



         assert brightness_factor >= -1.0 and brightness_factor <= 1.0
         __A             =		mplc.to_rgb(UpperCamelCase_			)
         __A             =		colorsys.rgb_to_hls(*mplc.to_rgb(UpperCamelCase_			)			)
         __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]	,		UpperCamelCase_	,		polygon_color[2]			)
         return modified_color
__a :    int								=				(
    np.array(
        [
            0.0_0_0,
            0.4_4_7,
            0.7_4_1,
            0.8_5_0,
            0.3_2_5,
            0.0_9_8,
            0.9_2_9,
            0.6_9_4,
            0.1_2_5,
            0.4_9_4,
            0.1_8_4,
            0.5_5_6,
            0.4_6_6,
            0.6_7_4,
            0.1_8_8,
            0.3_0_1,
            0.7_4_5,
            0.9_3_3,
            0.6_3_5,
            0.0_7_8,
            0.1_8_4,
            0.3_0_0,
            0.3_0_0,
            0.3_0_0,
            0.6_0_0,
            0.6_0_0,
            0.6_0_0,
            1.0_0_0,
            0.0_0_0,
            0.0_0_0,
            1.0_0_0,
            0.5_0_0,
            0.0_0_0,
            0.7_4_9,
            0.7_4_9,
            0.0_0_0,
            0.0_0_0,
            1.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.0_0_0,
            1.0_0_0,
            0.6_6_7,
            0.0_0_0,
            1.0_0_0,
            0.3_3_3,
            0.3_3_3,
            0.0_0_0,
            0.3_3_3,
            0.6_6_7,
            0.0_0_0,
            0.3_3_3,
            1.0_0_0,
            0.0_0_0,
            0.6_6_7,
            0.3_3_3,
            0.0_0_0,
            0.6_6_7,
            0.6_6_7,
            0.0_0_0,
            0.6_6_7,
            1.0_0_0,
            0.0_0_0,
            1.0_0_0,
            0.3_3_3,
            0.0_0_0,
            1.0_0_0,
            0.6_6_7,
            0.0_0_0,
            1.0_0_0,
            1.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.3_3_3,
            0.5_0_0,
            0.0_0_0,
            0.6_6_7,
            0.5_0_0,
            0.0_0_0,
            1.0_0_0,
            0.5_0_0,
            0.3_3_3,
            0.0_0_0,
            0.5_0_0,
            0.3_3_3,
            0.3_3_3,
            0.5_0_0,
            0.3_3_3,
            0.6_6_7,
            0.5_0_0,
            0.3_3_3,
            1.0_0_0,
            0.5_0_0,
            0.6_6_7,
            0.0_0_0,
            0.5_0_0,
            0.6_6_7,
            0.3_3_3,
            0.5_0_0,
            0.6_6_7,
            0.6_6_7,
            0.5_0_0,
            0.6_6_7,
            1.0_0_0,
            0.5_0_0,
            1.0_0_0,
            0.0_0_0,
            0.5_0_0,
            1.0_0_0,
            0.3_3_3,
            0.5_0_0,
            1.0_0_0,
            0.6_6_7,
            0.5_0_0,
            1.0_0_0,
            1.0_0_0,
            0.5_0_0,
            0.0_0_0,
            0.3_3_3,
            1.0_0_0,
            0.0_0_0,
            0.6_6_7,
            1.0_0_0,
            0.0_0_0,
            1.0_0_0,
            1.0_0_0,
            0.3_3_3,
            0.0_0_0,
            1.0_0_0,
            0.3_3_3,
            0.3_3_3,
            1.0_0_0,
            0.3_3_3,
            0.6_6_7,
            1.0_0_0,
            0.3_3_3,
            1.0_0_0,
            1.0_0_0,
            0.6_6_7,
            0.0_0_0,
            1.0_0_0,
            0.6_6_7,
            0.3_3_3,
            1.0_0_0,
            0.6_6_7,
            0.6_6_7,
            1.0_0_0,
            0.6_6_7,
            1.0_0_0,
            1.0_0_0,
            1.0_0_0,
            0.0_0_0,
            1.0_0_0,
            1.0_0_0,
            0.3_3_3,
            1.0_0_0,
            1.0_0_0,
            0.6_6_7,
            1.0_0_0,
            0.3_3_3,
            0.0_0_0,
            0.0_0_0,
            0.5_0_0,
            0.0_0_0,
            0.0_0_0,
            0.6_6_7,
            0.0_0_0,
            0.0_0_0,
            0.8_3_3,
            0.0_0_0,
            0.0_0_0,
            1.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.1_6_7,
            0.0_0_0,
            0.0_0_0,
            0.3_3_3,
            0.0_0_0,
            0.0_0_0,
            0.5_0_0,
            0.0_0_0,
            0.0_0_0,
            0.6_6_7,
            0.0_0_0,
            0.0_0_0,
            0.8_3_3,
            0.0_0_0,
            0.0_0_0,
            1.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.1_6_7,
            0.0_0_0,
            0.0_0_0,
            0.3_3_3,
            0.0_0_0,
            0.0_0_0,
            0.5_0_0,
            0.0_0_0,
            0.0_0_0,
            0.6_6_7,
            0.0_0_0,
            0.0_0_0,
            0.8_3_3,
            0.0_0_0,
            0.0_0_0,
            1.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.1_4_3,
            0.1_4_3,
            0.1_4_3,
            0.8_5_7,
            0.8_5_7,
            0.8_5_7,
            1.0_0_0,
            1.0_0_0,
            1.0_0_0,
        ]
    )
    .astype(np.floataa)
    .reshape(-1, 3)
)












def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     int     ,			__lowercase				:     int      )  -> int:





    """simple docstring"""

    __A             =		1.0
    for i in range(1     ,			r + 1      ):
        ret *= (n + 1 - i) / i
    return round(__lowercase      )



def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     int      )  -> int:





    """simple docstring"""

    return choose(8 + n     ,			__lowercase      ) + choose(9 + n     ,			__lowercase      ) - 1_0



def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     int      )  -> int:





    """simple docstring"""

    return sum(non_bouncy_exact(__lowercase      ) for i in range(1     ,			n + 1      )      )



def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     int = 1_0_0      )  -> int:





    """simple docstring"""

    return non_bouncy_upto(__lowercase      )


if __name__ == "__main__":
  print(f"""{solution() = }""")




