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


__SCREAMING_SNAKE_CASE	:					Any					=  1_000

class      lowerCamelCase_     :
      '''simple docstring'''

      def __init__(	self						:    Optional[Any]						, A						:    Optional[Any]						, A						:    Optional[int]=1.2						, A						:    Optional[Any]="g"						, A						:    int=0.5						, A						:    Union[str, Any]="-"						, A						:    int="test_out.jpg"						, A						:    Dict=True						, A						:    List[Any]=False						, A						:    List[str]=None						, A						:    Tuple=None						, A						:    List[Any]=0.7						, ):
             if isinstance(A						, torch.Tensor	):
                    _UpperCAmelCase					:  Optional[int]											=   img.numpy().astype("np.uint8"	)
             if isinstance(A						, A	):
                    _UpperCAmelCase					:  List[Any]											=   img_tensorize(A	)
             assert isinstance(A						, np.ndarray	)

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

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




      def 					_A     (	self						:    int						, A						:    Tuple						, A						:    Tuple=None	):
             if color is None:
                    _UpperCAmelCase					:  Optional[int]											=   self.edgecolor
             ((_UpperCAmelCase)				,  (_UpperCAmelCase)				,  (_UpperCAmelCase)				,  (_UpperCAmelCase))					:  List[str]											=   box
             _UpperCAmelCase					:  Any											=   xa - xa
             _UpperCAmelCase					:  Dict											=   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						:    Optional[Any]						, A						:    int						, A						:    int=None						, A						:    Optional[Any]=None						, A						:    List[str]=None						, A						:    Dict=None	):
             if len(boxes.shape	) > 2:
                    _UpperCAmelCase					:  str											=   boxes[0]
             if len(obj_ids.shape	) > 1:
                    _UpperCAmelCase					:  str											=   obj_ids[0]
             if len(obj_scores.shape	) > 1:
                    _UpperCAmelCase					:  List[str]											=   obj_scores[0]
             if len(attr_ids.shape	) > 1:
                    _UpperCAmelCase					:  Any											=   attr_ids[0]
             if len(attr_scores.shape	) > 1:
                    _UpperCAmelCase					:  Optional[int]											=   attr_scores[0]
             if isinstance(A						, torch.Tensor	):
                    _UpperCAmelCase					:  int											=   boxes.numpy()
             if isinstance(A						, A	):
                    _UpperCAmelCase					:  Optional[Any]											=   np.array(A	)
             assert isinstance(A						, np.ndarray	)
             _UpperCAmelCase					:  Any											=   np.prod(boxes[:, 2:] - boxes[:, :2]						, axis=1	)
             _UpperCAmelCase					:  List[Any]											=   np.argsort(-areas	).tolist()
             _UpperCAmelCase					:  str											=   boxes[sorted_idxs] if boxes is not None else None
             _UpperCAmelCase					:  Union[str, Any]											=   obj_ids[sorted_idxs] if obj_ids is not None else None
             _UpperCAmelCase					:  Tuple											=   obj_scores[sorted_idxs] if obj_scores is not None else None
             _UpperCAmelCase					:  Any											=   attr_ids[sorted_idxs] if attr_ids is not None else None
             _UpperCAmelCase					:  Optional[Any]											=   attr_scores[sorted_idxs] if attr_scores is not None else None

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




      def 					_A     (	self						:    Optional[int]						, A						:    int						, A						:    int						, A						:    Optional[int]	):
             _UpperCAmelCase				,  _UpperCAmelCase				,  _UpperCAmelCase				,  _UpperCAmelCase					:  Optional[Any]											=   box
             _UpperCAmelCase					:  str											=   (xa, ya)
             _UpperCAmelCase					:  Tuple											=   (ya - ya) * (xa - xa)
             _UpperCAmelCase					:  List[str]											=   _SMALL_OBJ * self.scale
             if instance_area < small or ya - ya < 40 * self.scale:
                    if ya >= self.height - 5:
                           _UpperCAmelCase					:  List[Any]											=   (xa, ya)
                    else:
                           _UpperCAmelCase					:  Tuple											=   (xa, ya)

             _UpperCAmelCase					:  Any											=   (ya - ya) / np.sqrt(self.height * self.width	)
             _UpperCAmelCase					:  List[Any]											=   self._change_color_brightness(A						, brightness_factor=0.7	)
             _UpperCAmelCase					:  str											=   np.clip((height_ratio - 0.02) / 0.08 + 1						, 1.2						, 2	)
             font_size *= 0.75 * self.font_size

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




      def 					_A     (	self						:    Any						, A						:    List[Any]						, A						:    int						, A						:    List[str]="g"						, A						:    Any="left"						, ):
             _UpperCAmelCase					:  int											=   0
             _UpperCAmelCase					:  List[str]											=   self.font_size
             _UpperCAmelCase					:  List[Any]											=   np.maximum(list(mplc.to_rgb(A	)	)						, 0.2	)
             _UpperCAmelCase					:  Dict											=   max(0.8						, np.max(A	)	)
             _UpperCAmelCase					:  Union[str, Any]											=   {
                 "facecolor": "black",
                 "alpha": self.alpha,
                 "pad": self.pad,
                 "edgecolor": "none",
             }
             _UpperCAmelCase				,  _UpperCAmelCase					:  Optional[Any]											=   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						:    int						, A						:    Dict=None	):
             if saveas is None:
                    _UpperCAmelCase					:  List[Any]											=   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						:    Optional[int]						, A						:    str						, A						:    int						, A						:    List[str]						, A						:    Any	):
             _UpperCAmelCase					:  Any											=   [self.idaobj[i] for i in classes]
             _UpperCAmelCase					:  str											=   [self.idaattr[i] for i in attr_classes]
             _UpperCAmelCase					:  str											=   [
                 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						:    Union[str, Any]						, A						:    Dict						, A						:    str	):
             _UpperCAmelCase					:  List[str]											=   [self.idaobj[i] for i in classes]
             if scores is not None:
                    if labels is None:
                           _UpperCAmelCase					:  Union[str, Any]											=   ["{:.0f}%".format(s * 100	) for s in scores]
                    else:
                           _UpperCAmelCase					:  Any											=   ["{} {:.0f}%".format(A						, s * 100	) for li, s in zip(A						, A	)]
             return labels




      def 					_A     (	self						:    Dict						, A						:    Dict=255	):
             _UpperCAmelCase					:  Union[str, Any]											=   np.random.randint(0						, len(_COLORS	)	)
             _UpperCAmelCase					:  Optional[Any]											=   _COLORS[idx] * maximum
             if not self.rgb:
                    _UpperCAmelCase					:  Optional[int]											=   ret[::-1]
             return ret




      def 					_A     (	self						:    List[Any]	):
             if not self.pynb:
                    _UpperCAmelCase				,  _UpperCAmelCase					:  Tuple											=   self.canvas.print_to_buffer()
                    if (width, height) != (self.width, self.height):
                           _UpperCAmelCase					:  Union[str, Any]											=   cva.resize(self.img						, (width, height)	)
                    else:
                           _UpperCAmelCase					:  Any											=   self.img
             else:
                    _UpperCAmelCase					:  List[Any]											=   io.BytesIO()  # works for cairo backend
                    self.canvas.print_rgba(A	)
                    _UpperCAmelCase				,  _UpperCAmelCase					:  Any											=   self.width, self.height
                    _UpperCAmelCase					:  Union[str, Any]											=   buf.getvalue()
                    _UpperCAmelCase					:  Optional[int]											=   self.img

             _UpperCAmelCase					:  str											=   np.frombuffer(A						, dtype="uint8"	)
             _UpperCAmelCase					:  Optional[Any]											=   buffer.reshape(A						, A						, 4	)
             _UpperCAmelCase				,  _UpperCAmelCase					:  List[str]											=   np.split(A						, [3]						, axis=2	)

             try:
                    import numexpr as ne  # fuse them with numexpr

                    _UpperCAmelCase					:  Optional[Any]											=   ne.evaluate("img * (1 - alpha / 255.0) + rgb * (alpha / 255.0)"	)
             except ImportError:
                    _UpperCAmelCase					:  int											=   alpha.astype("float32"	) / 255.0
                    _UpperCAmelCase					:  Tuple											=   img * (1 - alpha) + rgb * alpha

             return visualized_image.astype("uint8"	)





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

__SCREAMING_SNAKE_CASE	:					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)
)


'''simple docstring'''




import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers.testing_utils import require_vision
from transformers.utils import is_vision_available


if is_vision_available():
  from PIL import Image

  from transformers import AutoProcessor, BertTokenizer, CLIPImageProcessor, GitProcessor, PreTrainedTokenizerFast

@require_vision
class      lowerCamelCase_     (unittest.TestCase   ):
      '''simple docstring'''

      def 					_A     (	self						:    Any	):
             _UpperCAmelCase					:  List[Any]											=   tempfile.mkdtemp()

             _UpperCAmelCase					:  Any											=   CLIPImageProcessor()
             _UpperCAmelCase					:  Optional[int]											=   BertTokenizer.from_pretrained(
                 "hf-internal-testing/tiny-random-BertModel"						, model_input_names=["input_ids", "attention_mask"]	)

             _UpperCAmelCase					:  Dict											=   GitProcessor(A						, A	)

             processor.save_pretrained(self.tmpdirname	)




      def 					_A     (	self						:    Dict						, **A						:    Tuple	):
             return AutoProcessor.from_pretrained(self.tmpdirname						, **A	).tokenizer




      def 					_A     (	self						:    List[str]						, **A						:    str	):
             return AutoProcessor.from_pretrained(self.tmpdirname						, **A	).image_processor




      def 					_A     (	self						:    Optional[int]	):
             shutil.rmtree(self.tmpdirname	)




      def 					_A     (	self						:    Tuple	):
             _UpperCAmelCase					:  Dict											=   [np.random.randint(255						, size=(3, 30, 400)						, dtype=np.uinta	)]

             _UpperCAmelCase					:  Optional[Any]											=   [Image.fromarray(np.moveaxis(A						, 0						, -1	)	) for x in image_inputs]

             return image_inputs




      def 					_A     (	self						:    Optional[int]	):
             _UpperCAmelCase					:  Optional[int]											=   GitProcessor(tokenizer=self.get_tokenizer()						, image_processor=self.get_image_processor()	)
             processor.save_pretrained(self.tmpdirname	)

             _UpperCAmelCase					:  Dict											=   self.get_tokenizer(bos_token="(BOS)"						, eos_token="(EOS)"	)
             _UpperCAmelCase					:  Optional[Any]											=   self.get_image_processor(do_normalize=A						, padding_value=1.0	)

             _UpperCAmelCase					:  Union[str, Any]											=   GitProcessor.from_pretrained(
                 self.tmpdirname						, bos_token="(BOS)"						, eos_token="(EOS)"						, do_normalize=A						, padding_value=1.0	)

             self.assertEqual(processor.tokenizer.get_vocab()						, tokenizer_add_kwargs.get_vocab()	)
             self.assertIsInstance(processor.tokenizer						, A	)

             self.assertEqual(processor.image_processor.to_json_string()						, image_processor_add_kwargs.to_json_string()	)
             self.assertIsInstance(processor.image_processor						, A	)




      def 					_A     (	self						:    Union[str, Any]	):
             _UpperCAmelCase					:  Union[str, Any]											=   self.get_image_processor()
             _UpperCAmelCase					:  List[Any]											=   self.get_tokenizer()

             _UpperCAmelCase					:  int											=   GitProcessor(tokenizer=A						, image_processor=A	)

             _UpperCAmelCase					:  List[Any]											=   self.prepare_image_inputs()

             _UpperCAmelCase					:  Optional[Any]											=   image_processor(A						, return_tensors="np"	)
             _UpperCAmelCase					:  int											=   processor(images=A						, return_tensors="np"	)

             for key in input_feat_extract.keys():
                    self.assertAlmostEqual(input_feat_extract[key].sum()						, input_processor[key].sum()						, delta=1E-2	)




      def 					_A     (	self						:    Optional[Any]	):
             _UpperCAmelCase					:  str											=   self.get_image_processor()
             _UpperCAmelCase					:  Dict											=   self.get_tokenizer()

             _UpperCAmelCase					:  List[Any]											=   GitProcessor(tokenizer=A						, image_processor=A	)

             _UpperCAmelCase					:  List[str]											=   "lower newer"

             _UpperCAmelCase					:  Optional[int]											=   processor(text=A	)

             _UpperCAmelCase					:  Tuple											=   tokenizer(A						, return_token_type_ids=A	)

             for key in encoded_tok.keys():
                    self.assertListEqual(encoded_tok[key]						, encoded_processor[key]	)




      def 					_A     (	self						:    List[str]	):
             _UpperCAmelCase					:  Union[str, Any]											=   self.get_image_processor()
             _UpperCAmelCase					:  Dict											=   self.get_tokenizer()

             _UpperCAmelCase					:  Any											=   GitProcessor(tokenizer=A						, image_processor=A	)

             _UpperCAmelCase					:  Optional[Any]											=   "lower newer"
             _UpperCAmelCase					:  Optional[int]											=   self.prepare_image_inputs()

             _UpperCAmelCase					:  Any											=   processor(text=A						, images=A	)

             self.assertListEqual(list(inputs.keys()	)						, ["input_ids", "attention_mask", "pixel_values"]	)

             # test if it raises when no input is passed
             with pytest.raises(A	):
                    processor()




      def 					_A     (	self						:    Optional[Any]	):
             _UpperCAmelCase					:  List[str]											=   self.get_image_processor()
             _UpperCAmelCase					:  List[Any]											=   self.get_tokenizer()

             _UpperCAmelCase					:  List[str]											=   GitProcessor(tokenizer=A						, image_processor=A	)

             _UpperCAmelCase					:  List[str]											=   [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

             _UpperCAmelCase					:  Dict											=   processor.batch_decode(A	)
             _UpperCAmelCase					:  Dict											=   tokenizer.batch_decode(A	)

             self.assertListEqual(A						, A	)





      def 					_A     (	self						:    Any	):
             _UpperCAmelCase					:  List[Any]											=   self.get_image_processor()
             _UpperCAmelCase					:  Union[str, Any]											=   self.get_tokenizer()

             _UpperCAmelCase					:  Optional[int]											=   GitProcessor(tokenizer=A						, image_processor=A	)

             _UpperCAmelCase					:  Dict											=   "lower newer"
             _UpperCAmelCase					:  Tuple											=   self.prepare_image_inputs()

             _UpperCAmelCase					:  Dict											=   processor(text=A						, images=A	)

             # For now the processor supports only ['input_ids', 'attention_mask', 'pixel_values']
             self.assertListEqual(list(inputs.keys()	)						, ["input_ids", "attention_mask", "pixel_values"]	)

