

'''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


snake_case_       =       1_0_0_0
class 	SCREAMING_SNAKE_CASE__			:




    def __init__(					self				,     lowercase__				,     lowercase__=1.2				,     lowercase__="g"				,     lowercase__=0.5				,     lowercase__="-"				,     lowercase__="test_out.jpg"				,     lowercase__=True				,     lowercase__=False				,     lowercase__=None				,     lowercase__=None				,     lowercase__=0.7				,     ):






          """simple docstring"""






          if isinstance(lowercase__				,     torch.Tensor			):
                SCREAMING_SNAKE_CASE_      :			int     =       img.numpy().astype("np.uint8"			)
          if isinstance(lowercase__				,     lowercase__			):
                SCREAMING_SNAKE_CASE_      :			List[str]     =       img_tensorize(lowercase__			)
          assert isinstance(lowercase__				,     np.ndarray			)

          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       img.shape[1], img.shape[0]
          SCREAMING_SNAKE_CASE_      :			List[str]     =       mplfigure.Figure(frameon=lowercase__			)
          SCREAMING_SNAKE_CASE_      :			Dict     =       fig.get_dpi()
          SCREAMING_SNAKE_CASE_      :			List[str]     =       (width * scale + 1e-2) / dpi
          SCREAMING_SNAKE_CASE_      :			Dict     =       (height * scale + 1e-2) / dpi
          fig.set_size_inches(lowercase__				,     lowercase__			)
          SCREAMING_SNAKE_CASE_      :			int     =       fig.add_axes([0.0, 0.0, 1.0, 1.0]			)
          ax.axis("off"			)
          ax.set_xlim(0.0				,     lowercase__			)
          ax.set_ylim(lowercase__			)

          SCREAMING_SNAKE_CASE_      :			Any     =       saveas
          SCREAMING_SNAKE_CASE_      :			List[str]     =       rgb
          SCREAMING_SNAKE_CASE_      :			List[str]     =       pynb
          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       img
          SCREAMING_SNAKE_CASE_      :			Any     =       edgecolor
          SCREAMING_SNAKE_CASE_      :			Dict     =       0.5
          SCREAMING_SNAKE_CASE_      :			Any     =       linestyle
          SCREAMING_SNAKE_CASE_      :			str     =       int(np.sqrt(min(lowercase__				,     lowercase__			)			) * scale // 3			)
          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       width
          SCREAMING_SNAKE_CASE_      :			List[str]     =       height
          SCREAMING_SNAKE_CASE_      :			str     =       scale
          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       fig
          SCREAMING_SNAKE_CASE_      :			int     =       ax
          SCREAMING_SNAKE_CASE_      :			Dict     =       pad
          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       idaobj
          SCREAMING_SNAKE_CASE_      :			Dict     =       idaattr
          SCREAMING_SNAKE_CASE_      :			Tuple     =       FigureCanvasAgg(lowercase__			)




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__=None			):






          """simple docstring"""






          if color is None:
                SCREAMING_SNAKE_CASE_      :			List[Any]     =       self.edgecolor
          (SCREAMING_SNAKE_CASE_)      :			str     =       box
          SCREAMING_SNAKE_CASE_      :			Tuple     =       xa - xa
          SCREAMING_SNAKE_CASE_      :			int     =       ya - ya
          self.ax.add_patch(
              mpl.patches.Rectangle(
                  (xa, ya)				,     lowercase__				,     lowercase__				,     fill=lowercase__				,     edgecolor=lowercase__				,     linewidth=self.font_size // 3				,     alpha=self.alpha				,     linestyle=self.linestyle				,     )			)




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__=None				,     lowercase__=None				,     lowercase__=None				,     lowercase__=None			):






          """simple docstring"""






          if len(boxes.shape			) > 2:
                SCREAMING_SNAKE_CASE_      :			str     =       boxes[0]
          if len(obj_ids.shape			) > 1:
                SCREAMING_SNAKE_CASE_      :			Dict     =       obj_ids[0]
          if len(obj_scores.shape			) > 1:
                SCREAMING_SNAKE_CASE_      :			Tuple     =       obj_scores[0]
          if len(attr_ids.shape			) > 1:
                SCREAMING_SNAKE_CASE_      :			Optional[int]     =       attr_ids[0]
          if len(attr_scores.shape			) > 1:
                SCREAMING_SNAKE_CASE_      :			List[Any]     =       attr_scores[0]
          if isinstance(lowercase__				,     torch.Tensor			):
                SCREAMING_SNAKE_CASE_      :			List[Any]     =       boxes.numpy()
          if isinstance(lowercase__				,     lowercase__			):
                SCREAMING_SNAKE_CASE_      :			Dict     =       np.array(lowercase__			)
          assert isinstance(lowercase__				,     np.ndarray			)
          SCREAMING_SNAKE_CASE_      :			Any     =       np.prod(boxes[:, 2:] - boxes[:, :2]				,     axis=1			)
          SCREAMING_SNAKE_CASE_      :			Any     =       np.argsort(-areas			).tolist()
          SCREAMING_SNAKE_CASE_      :			Tuple     =       boxes[sorted_idxs] if boxes is not None else None
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       obj_ids[sorted_idxs] if obj_ids is not None else None
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       obj_scores[sorted_idxs] if obj_scores is not None else None
          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       attr_ids[sorted_idxs] if attr_ids is not None else None
          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       attr_scores[sorted_idxs] if attr_scores is not None else None

          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       [self._random_color(maximum=1			) for _ in range(len(lowercase__			)			)]
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       [assigned_colors[idx] for idx in sorted_idxs]
          if obj_ids is not None:
                SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       self._create_text_labels_attr(lowercase__				,     lowercase__				,     lowercase__				,     lowercase__			)
                for i in range(len(lowercase__			)			):
                      SCREAMING_SNAKE_CASE_      :			List[Any]     =       assigned_colors[i]
                      self.add_box(boxes[i]				,     lowercase__			)
                      self.draw_labels(labels[i]				,     boxes[i]				,     lowercase__			)




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__				,     lowercase__			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Dict     =       box
          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       (xa, ya)
          SCREAMING_SNAKE_CASE_      :			str     =       (ya - ya) * (xa - xa)
          SCREAMING_SNAKE_CASE_      :			List[str]     =       _SMALL_OBJ * self.scale
          if instance_area < small or ya - ya < 40 * self.scale:
                if ya >= self.height - 5:
                      SCREAMING_SNAKE_CASE_      :			List[str]     =       (xa, ya)
                else:
                      SCREAMING_SNAKE_CASE_      :			int     =       (xa, ya)

          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       (ya - ya) / np.sqrt(self.height * self.width			)
          SCREAMING_SNAKE_CASE_      :			Tuple     =       self._change_color_brightness(lowercase__				,     brightness_factor=0.7			)
          SCREAMING_SNAKE_CASE_      :			Tuple     =       np.clip((height_ratio - 0.02) / 0.08 + 1				,     1.2				,     2			)
          font_size *= 0.75 * self.font_size

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




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__				,     lowercase__="g"				,     lowercase__="left"				,     ):






          """simple docstring"""






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




    def   __lowerCamelCase      (					self				,     lowercase__=None			):






          """simple docstring"""






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




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__				,     lowercase__				,     lowercase__			):






          """simple docstring"""






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




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       [self.idaobj[i] for i in classes]
          if scores is not None:
                if labels is None:
                      SCREAMING_SNAKE_CASE_      :			Tuple     =       ['{:.0f}%'.format(s * 100			) for s in scores]
                else:
                      SCREAMING_SNAKE_CASE_      :			Optional[int]     =       ['{} {:.0f}%'.format(lowercase__				,     s * 100			) for li, s in zip(lowercase__				,     lowercase__			)]
          return labels




    def   __lowerCamelCase      (					self				,     lowercase__=255			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Dict     =       np.random.randint(0				,     len(_COLORS			)			)
          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       _COLORS[idx] * maximum
          if not self.rgb:
                SCREAMING_SNAKE_CASE_      :			List[Any]     =       ret[::-1]
          return ret




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          if not self.pynb:
                SCREAMING_SNAKE_CASE_      :			Any     =       self.canvas.print_to_buffer()
                if (width, height) != (self.width, self.height):
                      SCREAMING_SNAKE_CASE_      :			Tuple     =       cva.resize(self.img				,     (width, height)			)
                else:
                      SCREAMING_SNAKE_CASE_      :			Any     =       self.img
          else:
                SCREAMING_SNAKE_CASE_      :			Dict     =       io.BytesIO()  # works for cairo backend
                self.canvas.print_rgba(lowercase__			)
                SCREAMING_SNAKE_CASE_      :			Optional[int]     =       self.width, self.height
                SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       buf.getvalue()
                SCREAMING_SNAKE_CASE_      :			Optional[int]     =       self.img

          SCREAMING_SNAKE_CASE_      :			Dict     =       np.frombuffer(lowercase__				,     dtype="uint8"			)
          SCREAMING_SNAKE_CASE_      :			Tuple     =       buffer.reshape(lowercase__				,     lowercase__				,     4			)
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       np.split(lowercase__				,     [3]				,     axis=2			)

          try:
                import numexpr as ne  # fuse them with numexpr

                SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       ne.evaluate("img * (1 - alpha / 255.0) + rgb * (alpha / 255.0)"			)
          except ImportError:
                SCREAMING_SNAKE_CASE_      :			Any     =       alpha.astype("float32"			) / 255.0
                SCREAMING_SNAKE_CASE_      :			str     =       img * (1 - alpha) + rgb * alpha

          return visualized_image.astype("uint8"			)







    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__			):






          """simple docstring"""






          assert brightness_factor >= -1.0 and brightness_factor <= 1.0
          SCREAMING_SNAKE_CASE_      :			Any     =       mplc.to_rgb(lowercase__			)
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       colorsys.rgb_to_hls(*mplc.to_rgb(lowercase__			)			)
          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       polygon_color[1] + (brightness_factor * polygon_color[1])
          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       0.0 if modified_lightness < 0.0 else modified_lightness
          SCREAMING_SNAKE_CASE_      :			Dict     =       1.0 if modified_lightness > 1.0 else modified_lightness
          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       colorsys.hls_to_rgb(polygon_color[0]				,     lowercase__				,     polygon_color[2]			)
          return modified_color






snake_case_       =       (
    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)
)





'''simple docstring'''







import sys

sys.set_int_max_str_digits(0)  # type: ignore






def       lowerCAmelCase__       (				lowerCamelCase     :			int   ):
       _A     :	Optional[Any]      =					[0] * 11
       _A     :	str      =					[0] * 11

       # mark last 9 numbers
       for _ in range(9   ):
              _A     :	int      =					1
              _A     :	Optional[int]      =					number // 10
       # flag
       _A     :	List[Any]      =					True

       # check last 9 numbers for pandigitality

       for x in range(9   ):
              if not check_last[x + 1]:
                     _A     :	Optional[int]      =					False
       if not f:
              return f

       # mark first 9 numbers
       _A     :	Optional[int]      =					int(str(lowerCamelCase   )[:9]   )

       for _ in range(9   ):
              _A     :	Optional[Any]      =					1
              _A     :	str      =					number // 10

       # check first 9 numbers for pandigitality

       for x in range(9   ):
              if not check_front[x + 1]:
                     _A     :	Optional[Any]      =					False
       return f






def       lowerCAmelCase__       (				lowerCamelCase     :			int   ):
       _A     :	Dict      =					[0] * 11

       # mark last 9 numbers
       for _ in range(9   ):
              _A     :	List[str]      =					1
              _A     :	Dict      =					number // 10
       # flag
       _A     :	Optional[int]      =					True

       # check last 9 numbers for pandigitality

       for x in range(9   ):
              if not check_last[x + 1]:
                     _A     :	List[str]      =					False
       return f






def       lowerCAmelCase__       (				):
       _A     :	List[Any]      =					1
       _A     :	Dict      =					1
       _A     :	Dict      =					2
       # temporary Fibonacci numbers

       _A     :	List[Any]      =					1
       _A     :	Union[str, Any]      =					1
       _A     :	List[Any]      =					2
       # temporary Fibonacci numbers mod 1e9

       # mod m=1e9, done for fast optimisation
       _A     :	Tuple      =					[0] * 1000000
       _A     :	Any      =					1000000000

       for x in range(1000000   ):
              _A     :	Tuple      =					(aa + ba) % m
              _A     :	Optional[Any]      =					ba % m
              _A     :	str      =					ca % m
              if checka(lowerCamelCase   ):
                     _A     :	Dict      =					1

       for x in range(1000000   ):
              _A     :	List[str]      =					a + b
              _A     :	Optional[int]      =					b
              _A     :	str      =					c
              # perform check only if in tocheck
              if tocheck[x + 3] and check(lowerCamelCase   ):
                     return x + 3  # first 2 already done
       return -1


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






