





_A :   Union[str, Any]  			=  range(2, 20 + 1)
_A :   Tuple  			=  [10**k for k in range(ks[-1] + 1)]
_A :   dict[int, dict[int, list[list[int]]]]  			=  {}



def 	_a						(   UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase					)    ->    List[Any]:







   """simple docstring"""
   lowerCamelCase__       :						str        =							sum(a_i[j] for j in range(UpperCAmelCase      ,  len(UpperCAmelCase					)					)					)
   lowerCamelCase__       :						Any        =							sum(a_i[j] * base[j] for j in range(min(len(UpperCAmelCase					)      ,  UpperCAmelCase					)					)					)

   lowerCamelCase__       ,							lowerCamelCase__       :						str        =							0, 0
   lowerCamelCase__       :						str        =							n - i

   lowerCamelCase__       :						Optional[int]        =							memo.get(UpperCAmelCase					)

   if sub_memo is not None:
      lowerCamelCase__       :						Union[str, Any]        =							sub_memo.get(UpperCAmelCase					)

      if jumps is not None and len(UpperCAmelCase					) > 0:
         # find and make the largest jump without going over
         lowerCamelCase__       :						Union[str, Any]        =							-1
         for _k in range(len(UpperCAmelCase					) - 1      ,  -1      ,  -1					):
            if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
               lowerCamelCase__       :						Tuple        =							_k
               break

         if max_jump >= 0:
            lowerCamelCase__       ,							lowerCamelCase__       ,							lowerCamelCase__       :						Any        =							jumps[max_jump]
            # since the difference between jumps is cached, add c
            lowerCamelCase__       :						int        =							diff + c
            for j in range(min(UpperCAmelCase      ,  len(UpperCAmelCase					)					)					):
               lowerCamelCase__       ,							lowerCamelCase__       :						Optional[int]        =							divmod(UpperCAmelCase      ,  10					)
            if new_c > 0:
               add(UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase					)

      else:
         lowerCamelCase__       :						Union[str, Any]        =							[]
   else:
      lowerCamelCase__       :						List[Any]        =							{c: []}
      lowerCamelCase__       :						Union[str, Any]        =							sub_memo

   if dn >= max_dn or c + diff >= base[k]:
      return diff, dn

   if k > ks[0]:
      while True:
         # keep doing smaller jumps
         lowerCamelCase__       ,							lowerCamelCase__       :						Tuple        =							next_term(UpperCAmelCase      ,  k - 1      ,  i + dn      ,  UpperCAmelCase					)
         diff += _diff
         dn += terms_jumped

         if dn >= max_dn or c + diff >= base[k]:
            break
   else:
      # would be too small a jump, just compute sequential terms instead
      lowerCamelCase__       ,							lowerCamelCase__       :						List[str]        =							compute(UpperCAmelCase      ,  UpperCAmelCase      ,  i + dn      ,  UpperCAmelCase					)
      diff += _diff
      dn += terms_jumped

   lowerCamelCase__       :						str        =							sub_memo[c]

   # keep jumps sorted by # of terms skipped
   lowerCamelCase__       :						Optional[int]        =							0
   while j < len(UpperCAmelCase					):
      if jumps[j][1] > dn:
         break
      j += 1

   # cache the jump for this value digitsum(b) and c
   sub_memo[c].insert(UpperCAmelCase      ,  (diff, dn, k)					)
   return (diff, dn)



def 	_a						(   UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase					)    ->    List[Any]:







   """simple docstring"""
   if i >= n:
      return 0, i
   if k > len(UpperCAmelCase					):
      a_i.extend([0 for _ in range(k - len(UpperCAmelCase					)					)]					)

   # note: a_i -> b * 10^k + c
   # ds_b -> digitsum(b)
   # ds_c -> digitsum(c)
   lowerCamelCase__       :						str        =							i
   lowerCamelCase__       ,							lowerCamelCase__       ,							lowerCamelCase__       :						Union[str, Any]        =							0, 0, 0
   for j in range(len(UpperCAmelCase					)					):
      if j >= k:
         ds_b += a_i[j]
      else:
         ds_c += a_i[j]

   while i < n:
      i += 1
      lowerCamelCase__       :						List[Any]        =							ds_c + ds_b
      diff += addend
      lowerCamelCase__       :						str        =							0
      for j in range(UpperCAmelCase					):
         lowerCamelCase__       :						Optional[int]        =							a_i[j] + addend
         lowerCamelCase__       ,							lowerCamelCase__       :						Any        =							divmod(UpperCAmelCase      ,  10					)

         ds_c += a_i[j]

      if addend > 0:
         break

   if addend > 0:
      add(UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase					)
   return diff, i - start_i



def 	_a						(   UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase					)    ->    List[Any]:







   """simple docstring"""
   for j in range(UpperCAmelCase      ,  len(UpperCAmelCase					)					):
      lowerCamelCase__       :						int        =							digits[j] + addend
      if s >= 10:
         lowerCamelCase__       ,							lowerCamelCase__       :						Dict        =							divmod(UpperCAmelCase      ,  10					)
         lowerCamelCase__       :						Optional[int]        =							addend // 10 + quotient
      else:
         lowerCamelCase__       :						str        =							s
         lowerCamelCase__       :						Dict        =							addend // 10

      if addend == 0:
         break

   while addend > 0:
      lowerCamelCase__       ,							lowerCamelCase__       :						str        =							divmod(UpperCAmelCase      ,  10					)
      digits.append(UpperCAmelCase					)



def 	_a						(   UpperCAmelCase = 10**15					)    ->    int:







   """simple docstring"""
   lowerCamelCase__       :						Any        =							[1]
   lowerCamelCase__       :						Optional[int]        =							1
   lowerCamelCase__       :						int        =							0
   while True:
      lowerCamelCase__       ,							lowerCamelCase__       :						Union[str, Any]        =							next_term(UpperCAmelCase      ,  20      ,  i + dn      ,  UpperCAmelCase					)
      dn += terms_jumped
      if dn == n - i:
         break

   lowerCamelCase__       :						str        =							0
   for j in range(len(UpperCAmelCase					)					):
      a_n += digits[j] * 10**j
   return a_n


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










import json
import pathlib
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision, slow
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
       import torch

if is_vision_available():
       from PIL import Image

       from transformers import DetrImageProcessor


class        __SCREAMING_SNAKE_CASE      (			unittest.TestCase ):







       def __init__(				self					:     Optional[int]		, A					:     Union[str, Any]		, A					:     Any=7		, A					:     Optional[int]=3		, A					:     Tuple=3_0		, A					:     List[Any]=4_0_0		, A					:     str=True		, A					:     Optional[int]=None		, A					:     Tuple=True		, A					:     Union[str, Any]=1 / 2_5_5		, A					:     Any=True		, A					:     Optional[int]=[0.5, 0.5, 0.5]		, A					:     Optional[int]=[0.5, 0.5, 0.5]		, A					:     str=True		, )       ->List[Any]:
          # by setting size["longest_edge"] > max_resolution we're effectively not testing this :p
          lowerCamelCase__       :						Union[str, Any]        =							size if size is not None else {'''shortest_edge''': 1_8, '''longest_edge''': 1_3_3_3}
          lowerCamelCase__       :						List[str]        =							parent
          lowerCamelCase__       :						Union[str, Any]        =							batch_size
          lowerCamelCase__       :						int        =							num_channels
          lowerCamelCase__       :						Optional[Any]        =							min_resolution
          lowerCamelCase__       :						List[Any]        =							max_resolution
          lowerCamelCase__       :						int        =							do_resize
          lowerCamelCase__       :						List[str]        =							size
          lowerCamelCase__       :						Union[str, Any]        =							do_rescale
          lowerCamelCase__       :						Optional[int]        =							rescale_factor
          lowerCamelCase__       :						List[str]        =							do_normalize
          lowerCamelCase__       :						Tuple        =							image_mean
          lowerCamelCase__       :						str        =							image_std
          lowerCamelCase__       :						List[Any]        =							do_pad







       def 						__lowerCamelCase   (				self					:     List[str]      )       ->Dict:
          return {
              "do_resize": self.do_resize,
              "size": self.size,
              "do_rescale": self.do_rescale,
              "rescale_factor": self.rescale_factor,
              "do_normalize": self.do_normalize,
              "image_mean": self.image_mean,
              "image_std": self.image_std,
              "do_pad": self.do_pad,
          }







       def 						__lowerCamelCase   (				self					:     Tuple		, A					:     int		, A					:     List[str]=False      )       ->int:
          if not batched:
             lowerCamelCase__       :						Union[str, Any]        =							image_inputs[0]
             if isinstance(A		, Image.Image      ):
                lowerCamelCase__       ,							lowerCamelCase__       :						Union[str, Any]        =							image.size
             else:
                lowerCamelCase__       ,							lowerCamelCase__       :						Optional[int]        =							image.shape[1], image.shape[2]
             if w < h:
                lowerCamelCase__       :						List[Any]        =							int(self.size['''shortest_edge'''] * h / w      )
                lowerCamelCase__       :						List[Any]        =							self.size['''shortest_edge''']
             elif w > h:
                lowerCamelCase__       :						List[Any]        =							self.size['''shortest_edge''']
                lowerCamelCase__       :						Dict        =							int(self.size['''shortest_edge'''] * w / h      )
             else:
                lowerCamelCase__       :						List[Any]        =							self.size['''shortest_edge''']
                lowerCamelCase__       :						Any        =							self.size['''shortest_edge''']

          else:
             lowerCamelCase__       :						Optional[Any]        =							[]
             for image in image_inputs:
                lowerCamelCase__       ,							lowerCamelCase__       :						Any        =							self.get_expected_values([image]      )
                expected_values.append((expected_height, expected_width)      )
             lowerCamelCase__       :						Dict        =							max(A		, key=lambda A      : item[0]      )[0]
             lowerCamelCase__       :						Dict        =							max(A		, key=lambda A      : item[1]      )[1]

          return expected_height, expected_width


@require_torch
@require_vision
class        __SCREAMING_SNAKE_CASE      (			lowerCAmelCase_					,unittest.TestCase ):
       _UpperCAmelCase				:  Optional[Any]			   =   DetrImageProcessor if is_vision_available() else None







       def 						__lowerCamelCase   (				self					:     Optional[int]      )       ->Dict:
          lowerCamelCase__       :						Optional[int]        =							DetrImageProcessingTester(self      )







       @property
       def 						__lowerCamelCase   (				self					:     Dict      )       ->Any:
          return self.image_processor_tester.prepare_image_processor_dict()







       def 						__lowerCamelCase   (				self					:     int      )       ->Union[str, Any]:
          lowerCamelCase__       :						Optional[Any]        =							self.image_processing_class(**self.image_processor_dict      )
          self.assertTrue(hasattr(A		, '''image_mean'''      )      )
          self.assertTrue(hasattr(A		, '''image_std'''      )      )
          self.assertTrue(hasattr(A		, '''do_normalize'''      )      )
          self.assertTrue(hasattr(A		, '''do_rescale'''      )      )
          self.assertTrue(hasattr(A		, '''rescale_factor'''      )      )
          self.assertTrue(hasattr(A		, '''do_resize'''      )      )
          self.assertTrue(hasattr(A		, '''size'''      )      )
          self.assertTrue(hasattr(A		, '''do_pad'''      )      )







       def 						__lowerCamelCase   (				self					:     int      )       ->Union[str, Any]:
          lowerCamelCase__       :						List[Any]        =							self.image_processing_class.from_dict(self.image_processor_dict      )
          self.assertEqual(image_processor.size		, {'''shortest_edge''': 1_8, '''longest_edge''': 1_3_3_3}      )
          self.assertEqual(image_processor.do_pad		, A      )

          lowerCamelCase__       :						str        =							self.image_processing_class.from_dict(
              self.image_processor_dict		, size=4_2		, max_size=8_4		, pad_and_return_pixel_mask=A      )
          self.assertEqual(image_processor.size		, {'''shortest_edge''': 4_2, '''longest_edge''': 8_4}      )
          self.assertEqual(image_processor.do_pad		, A      )







       def 						__lowerCamelCase   (				self					:     Union[str, Any]      )       ->Optional[Any]:
          pass







       def 						__lowerCamelCase   (				self					:     str      )       ->Optional[Any]:
          # Initialize image_processing
          lowerCamelCase__       :						Any        =							self.image_processing_class(**self.image_processor_dict      )
          # create random PIL images
          lowerCamelCase__       :						str        =							prepare_image_inputs(self.image_processor_tester		, equal_resolution=A      )
          for image in image_inputs:
             self.assertIsInstance(A		, Image.Image      )

          # Test not batched input
          lowerCamelCase__       :						Optional[Any]        =							image_processing(image_inputs[0]		, return_tensors='''pt'''      ).pixel_values

          lowerCamelCase__       ,							lowerCamelCase__       :						str        =							self.image_processor_tester.get_expected_values(A      )

          self.assertEqual(
              encoded_images.shape		, (1, self.image_processor_tester.num_channels, expected_height, expected_width)		, )

          # Test batched
          lowerCamelCase__       ,							lowerCamelCase__       :						int        =							self.image_processor_tester.get_expected_values(A		, batched=A      )

          lowerCamelCase__       :						Any        =							image_processing(A		, return_tensors='''pt'''      ).pixel_values
          self.assertEqual(
              encoded_images.shape		, (
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.num_channels,
                  expected_height,
                  expected_width,
              )		, )







       def 						__lowerCamelCase   (				self					:     List[str]      )       ->List[str]:
          # Initialize image_processing
          lowerCamelCase__       :						Any        =							self.image_processing_class(**self.image_processor_dict      )
          # create random numpy tensors
          lowerCamelCase__       :						int        =							prepare_image_inputs(self.image_processor_tester		, equal_resolution=A		, numpify=A      )
          for image in image_inputs:
             self.assertIsInstance(A		, np.ndarray      )

          # Test not batched input
          lowerCamelCase__       :						List[str]        =							image_processing(image_inputs[0]		, return_tensors='''pt'''      ).pixel_values

          lowerCamelCase__       ,							lowerCamelCase__       :						str        =							self.image_processor_tester.get_expected_values(A      )

          self.assertEqual(
              encoded_images.shape		, (1, self.image_processor_tester.num_channels, expected_height, expected_width)		, )

          # Test batched
          lowerCamelCase__       :						List[Any]        =							image_processing(A		, return_tensors='''pt'''      ).pixel_values

          lowerCamelCase__       ,							lowerCamelCase__       :						Optional[Any]        =							self.image_processor_tester.get_expected_values(A		, batched=A      )

          self.assertEqual(
              encoded_images.shape		, (
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.num_channels,
                  expected_height,
                  expected_width,
              )		, )







       def 						__lowerCamelCase   (				self					:     Any      )       ->Any:
          # Initialize image_processing
          lowerCamelCase__       :						Optional[Any]        =							self.image_processing_class(**self.image_processor_dict      )
          # create random PyTorch tensors
          lowerCamelCase__       :						List[str]        =							prepare_image_inputs(self.image_processor_tester		, equal_resolution=A		, torchify=A      )
          for image in image_inputs:
             self.assertIsInstance(A		, torch.Tensor      )

          # Test not batched input
          lowerCamelCase__       :						str        =							image_processing(image_inputs[0]		, return_tensors='''pt'''      ).pixel_values

          lowerCamelCase__       ,							lowerCamelCase__       :						str        =							self.image_processor_tester.get_expected_values(A      )

          self.assertEqual(
              encoded_images.shape		, (1, self.image_processor_tester.num_channels, expected_height, expected_width)		, )

          # Test batched
          lowerCamelCase__       :						str        =							image_processing(A		, return_tensors='''pt'''      ).pixel_values

          lowerCamelCase__       ,							lowerCamelCase__       :						str        =							self.image_processor_tester.get_expected_values(A		, batched=A      )

          self.assertEqual(
              encoded_images.shape		, (
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.num_channels,
                  expected_height,
                  expected_width,
              )		, )







       @slow
       def 						__lowerCamelCase   (				self					:     Tuple      )       ->List[Any]:
          # prepare image and target
          lowerCamelCase__       :						Union[str, Any]        =							Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''      )
          with open('''./tests/fixtures/tests_samples/COCO/coco_annotations.txt'''		, '''r'''      ) as f:
             lowerCamelCase__       :						Union[str, Any]        =							json.loads(f.read()      )

          lowerCamelCase__       :						List[str]        =							{'''image_id''': 3_9_7_6_9, '''annotations''': target}

          # encode them
          lowerCamelCase__       :						Optional[int]        =							DetrImageProcessor.from_pretrained('''facebook/detr-resnet-50'''      )
          lowerCamelCase__       :						List[Any]        =							image_processing(images=A		, annotations=A		, return_tensors='''pt'''      )

          # verify pixel values
          lowerCamelCase__       :						Optional[int]        =							torch.Size([1, 3, 8_0_0, 1_0_6_6]      )
          self.assertEqual(encoding['''pixel_values'''].shape		, A      )

          lowerCamelCase__       :						Any        =							torch.tensor([0.27_96, 0.31_38, 0.34_81]      )
          self.assertTrue(torch.allclose(encoding['''pixel_values'''][0, 0, 0, :3]		, A		, atol=1e-4      )      )

          # verify area
          lowerCamelCase__       :						Dict        =							torch.tensor([58_87.96_00, 1_12_50.20_61, 48_93_53.84_38, 83_71_22.75_00, 14_79_67.51_56, 16_57_32.34_38]      )
          self.assertTrue(torch.allclose(encoding['''labels'''][0]['''area''']		, A      )      )
          # verify boxes
          lowerCamelCase__       :						Any        =							torch.Size([6, 4]      )
          self.assertEqual(encoding['''labels'''][0]['''boxes'''].shape		, A      )
          lowerCamelCase__       :						str        =							torch.tensor([0.55_03, 0.27_65, 0.06_04, 0.22_15]      )
          self.assertTrue(torch.allclose(encoding['''labels'''][0]['''boxes'''][0]		, A		, atol=1e-3      )      )
          # verify image_id
          lowerCamelCase__       :						str        =							torch.tensor([3_9_7_6_9]      )
          self.assertTrue(torch.allclose(encoding['''labels'''][0]['''image_id''']		, A      )      )
          # verify is_crowd
          lowerCamelCase__       :						List[str]        =							torch.tensor([0, 0, 0, 0, 0, 0]      )
          self.assertTrue(torch.allclose(encoding['''labels'''][0]['''iscrowd''']		, A      )      )
          # verify class_labels
          lowerCamelCase__       :						List[Any]        =							torch.tensor([7_5, 7_5, 6_3, 6_5, 1_7, 1_7]      )
          self.assertTrue(torch.allclose(encoding['''labels'''][0]['''class_labels''']		, A      )      )
          # verify orig_size
          lowerCamelCase__       :						str        =							torch.tensor([4_8_0, 6_4_0]      )
          self.assertTrue(torch.allclose(encoding['''labels'''][0]['''orig_size''']		, A      )      )
          # verify size
          lowerCamelCase__       :						str        =							torch.tensor([8_0_0, 1_0_6_6]      )
          self.assertTrue(torch.allclose(encoding['''labels'''][0]['''size''']		, A      )      )







       @slow
       def 						__lowerCamelCase   (				self					:     Optional[Any]      )       ->List[str]:
          # prepare image, target and masks_path
          lowerCamelCase__       :						Any        =							Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''      )
          with open('''./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt'''		, '''r'''      ) as f:
             lowerCamelCase__       :						Optional[Any]        =							json.loads(f.read()      )

          lowerCamelCase__       :						Union[str, Any]        =							{'''file_name''': '''000000039769.png''', '''image_id''': 3_9_7_6_9, '''segments_info''': target}

          lowerCamelCase__       :						List[Any]        =							pathlib.Path('''./tests/fixtures/tests_samples/COCO/coco_panoptic'''      )

          # encode them
          lowerCamelCase__       :						Any        =							DetrImageProcessor.from_pretrained('''facebook/detr-resnet-50-panoptic'''      )
          lowerCamelCase__       :						Tuple        =							image_processing(images=A		, annotations=A		, masks_path=A		, return_tensors='''pt'''      )

          # verify pixel values
          lowerCamelCase__       :						Optional[Any]        =							torch.Size([1, 3, 8_0_0, 1_0_6_6]      )
          self.assertEqual(encoding['''pixel_values'''].shape		, A      )

          lowerCamelCase__       :						str        =							torch.tensor([0.27_96, 0.31_38, 0.34_81]      )
          self.assertTrue(torch.allclose(encoding['''pixel_values'''][0, 0, 0, :3]		, A		, atol=1e-4      )      )

          # verify area
          lowerCamelCase__       :						int        =							torch.tensor([14_79_79.68_75, 16_55_27.04_69, 48_46_38.59_38, 1_12_92.93_75, 58_79.65_62, 76_34.11_47]      )
          self.assertTrue(torch.allclose(encoding['''labels'''][0]['''area''']		, A      )      )
          # verify boxes
          lowerCamelCase__       :						Optional[Any]        =							torch.Size([6, 4]      )
          self.assertEqual(encoding['''labels'''][0]['''boxes'''].shape		, A      )
          lowerCamelCase__       :						Optional[Any]        =							torch.tensor([0.26_25, 0.54_37, 0.46_88, 0.86_25]      )
          self.assertTrue(torch.allclose(encoding['''labels'''][0]['''boxes'''][0]		, A		, atol=1e-3      )      )
          # verify image_id
          lowerCamelCase__       :						int        =							torch.tensor([3_9_7_6_9]      )
          self.assertTrue(torch.allclose(encoding['''labels'''][0]['''image_id''']		, A      )      )
          # verify is_crowd
          lowerCamelCase__       :						Dict        =							torch.tensor([0, 0, 0, 0, 0, 0]      )
          self.assertTrue(torch.allclose(encoding['''labels'''][0]['''iscrowd''']		, A      )      )
          # verify class_labels
          lowerCamelCase__       :						int        =							torch.tensor([1_7, 1_7, 6_3, 7_5, 7_5, 9_3]      )
          self.assertTrue(torch.allclose(encoding['''labels'''][0]['''class_labels''']		, A      )      )
          # verify masks
          lowerCamelCase__       :						Union[str, Any]        =							8_2_2_8_7_3
          self.assertEqual(encoding['''labels'''][0]['''masks'''].sum().item()		, A      )
          # verify orig_size
          lowerCamelCase__       :						List[Any]        =							torch.tensor([4_8_0, 6_4_0]      )
          self.assertTrue(torch.allclose(encoding['''labels'''][0]['''orig_size''']		, A      )      )
          # verify size
          lowerCamelCase__       :						Tuple        =							torch.tensor([8_0_0, 1_0_6_6]      )
          self.assertTrue(torch.allclose(encoding['''labels'''][0]['''size''']		, A      )      )



