
def 				UpperCAmelCase_						(				__SCREAMING_SNAKE_CASE				):
	lowercase	    =       [[0 for _ in range(__SCREAMING_SNAKE_CASE				)] for _ in range(m + 1				)]
	for i in range(m + 1				):
		lowercase	    =       1

	for n in range(m + 1				):
		for k in range(1					,				__SCREAMING_SNAKE_CASE				):
			memo[n][k] += memo[n][k - 1]
			if n - k > 0:
				memo[n][k] += memo[n - k - 1][k]

	return memo[m][m - 1]


if __name__ == "__main__":
	import sys

	if len(sys.argv) == 1:
		try:
			UpperCAmelCase       =					int(input('''Enter a number: ''').strip())
			print(partition(n))
		except ValueError:
			print('''Please enter a number.''')
	else:
		try:
			UpperCAmelCase       =					int(sys.argv[1])
			print(partition(n))
		except ValueError:
			print('''Please pass a number.''')




from typing import Dict, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    flip_channel_order,
    get_resize_output_image_size,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, is_vision_available, logging


if is_vision_available():
   import PIL

if is_torch_available():
   import torch


_lowerCamelCase      :					Dict					    =      logging.get_logger(__name__)





class        lowerCAmelCase__  (					__magic_name__			):



       '''simple docstring'''







       lowercase_						=    ["""pixel_values"""]

       def __init__(							self ,   lowercase__ = True ,   lowercase__ = None ,   lowercase__ = PILImageResampling.BILINEAR ,   lowercase__ = True ,   lowercase__ = 1 / 2_5_5 ,   lowercase__ = True ,   lowercase__ = None ,   lowercase__ = True ,   **lowercase__ ,   ):







             '''simple docstring'''



             super().__init__(**lowercase__     )
             __A    =size if size is not None else {'''shortest_edge''': 2_2_4}
             __A    =get_size_dict(lowercase__ ,   default_to_square=lowercase__     )
             __A    =crop_size if crop_size is not None else {'''height''': 2_5_6, '''width''': 2_5_6}
             __A    =get_size_dict(lowercase__ ,   param_name='''crop_size'''     )

             __A    =do_resize
             __A    =size
             __A    =resample
             __A    =do_rescale
             __A    =rescale_factor
             __A    =do_center_crop
             __A    =crop_size
             __A    =do_flip_channel_order

       def     __UpperCamelCase     (							self ,   lowercase__ ,   lowercase__ ,   lowercase__ = PIL.Image.BILINEAR ,   lowercase__ = None ,   **lowercase__ ,   ):







             '''simple docstring'''



             __A    =get_size_dict(lowercase__ ,   default_to_square=lowercase__     )
             if "shortest_edge" not in size:
                   raise ValueError(f'''The `size` dictionary must contain the key `shortest_edge`. Got {size.keys()}'''     )
             __A    =get_resize_output_image_size(lowercase__ ,   size=size['''shortest_edge'''] ,   default_to_square=lowercase__     )
             return resize(lowercase__ ,   size=lowercase__ ,   resample=lowercase__ ,   data_format=lowercase__ ,   **lowercase__     )

       def     __UpperCamelCase     (							self ,   lowercase__ ,   lowercase__ ,   lowercase__ = None ,   **lowercase__ ,   ):







             '''simple docstring'''



             __A    =get_size_dict(lowercase__     )
             if "height" not in size or "width" not in size:
                   raise ValueError(f'''The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}'''     )
             return center_crop(lowercase__ ,   size=(size['''height'''], size['''width''']) ,   data_format=lowercase__ ,   **lowercase__     )

       def     __UpperCamelCase     (							self ,   lowercase__ ,   lowercase__ ,   lowercase__ = None ,   **lowercase__ ,   ):







             '''simple docstring'''



             return rescale(lowercase__ ,   scale=lowercase__ ,   data_format=lowercase__ ,   **lowercase__     )

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







             '''simple docstring'''



             return flip_channel_order(lowercase__ ,   data_format=lowercase__     )

       def     __UpperCamelCase     (							self ,   lowercase__ ,   lowercase__ = None ,   lowercase__ = None ,   lowercase__ = None ,   lowercase__ = None ,   lowercase__ = None ,   lowercase__ = None ,   lowercase__ = None ,   lowercase__ = None ,   lowercase__ = None ,   lowercase__ = ChannelDimension.FIRST ,   **lowercase__ ,   ):







             '''simple docstring'''



             __A    =do_resize if do_resize is not None else self.do_resize
             __A    =resample if resample is not None else self.resample
             __A    =do_rescale if do_rescale is not None else self.do_rescale
             __A    =rescale_factor if rescale_factor is not None else self.rescale_factor
             __A    =do_center_crop if do_center_crop is not None else self.do_center_crop
             __A    =(
                 do_flip_channel_order if do_flip_channel_order is not None else self.do_flip_channel_order
             )

             __A    =size if size is not None else self.size
             __A    =get_size_dict(lowercase__ ,   default_to_square=lowercase__     )
             __A    =crop_size if crop_size is not None else self.crop_size
             __A    =get_size_dict(lowercase__ ,   param_name='''crop_size'''     )

             __A    =make_list_of_images(lowercase__     )

             if not valid_images(lowercase__     ):
                   raise ValueError(
                       '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
                       '''torch.Tensor, tf.Tensor or jax.ndarray.'''     )

             if do_resize and size is None:
                   raise ValueError('''Size must be specified if do_resize is True.'''     )

             if do_rescale and rescale_factor is None:
                   raise ValueError('''Rescale factor must be specified if do_rescale is True.'''     )

             if do_center_crop and crop_size is None:
                   raise ValueError('''Crop size must be specified if do_center_crop is True.'''     )

             # All transformations expect numpy arrays.
             __A    =[to_numpy_array(lowercase__     ) for image in images]

             if do_resize:
                   __A    =[self.resize(image=lowercase__ ,   size=lowercase__ ,   resample=lowercase__     ) for image in images]

             if do_center_crop:
                   __A    =[self.center_crop(image=lowercase__ ,   size=lowercase__     ) for image in images]

             if do_rescale:
                   __A    =[self.rescale(image=lowercase__ ,   scale=lowercase__     ) for image in images]

             # the pretrained checkpoints assume images are BGR, not RGB
             if do_flip_channel_order:
                   __A    =[self.flip_channel_order(image=lowercase__     ) for image in images]

             __A    =[to_channel_dimension_format(lowercase__ ,   lowercase__     ) for image in images]

             __A    ={'''pixel_values''': images}
             return BatchFeature(data=lowercase__ ,   tensor_type=lowercase__     )


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







             '''simple docstring'''



             __A    =outputs.logits

             # Resize logits and compute semantic segmentation maps
             if target_sizes is not None:
                   if len(lowercase__     ) != len(lowercase__     ):
                         raise ValueError(
                             '''Make sure that you pass in as many target sizes as the batch dimension of the logits'''     )

                   if is_torch_tensor(lowercase__     ):
                         __A    =target_sizes.numpy()

                   __A    =[]

                   for idx in range(len(lowercase__     )     ):
                         __A    =torch.nn.functional.interpolate(
                             logits[idx].unsqueeze(dim=0     ) ,   size=target_sizes[idx] ,   mode='''bilinear''' ,   align_corners=lowercase__     )
                         __A    =resized_logits[0].argmax(dim=0     )
                         semantic_segmentation.append(lowercase__     )
             else:
                   __A    =logits.argmax(dim=1     )
                   __A    =[semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]     )]

             return semantic_segmentation


