
import unittest

import numpy as np

from transformers.testing_utils import require_flax, require_tf, require_torch
from transformers.utils import (
    expand_dims,
    flatten_dict,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    reshape,
    squeeze,
    transpose,
)


if is_flax_available():
					import jax.numpy as jnp

if is_tf_available():
					import tensorflow as tf

if is_torch_available():
					import torch


class 				lowercase					(		unittest.TestCase   ):



		def __UpperCamelCase ( self       )  ->					List[str]:
				"""simple docstring"""
				UpperCamelCase		=     {
				    '''task_specific_params''': {
				        '''summarization''': {'''length_penalty''': 1.0, '''max_length''': 128, '''min_length''': 12, '''num_beams''': 4},
				        '''summarization_cnn''': {'''length_penalty''': 2.0, '''max_length''': 142, '''min_length''': 56, '''num_beams''': 4},
				        '''summarization_xsum''': {'''length_penalty''': 1.0, '''max_length''': 62, '''min_length''': 11, '''num_beams''': 6},
				    }
				}
				UpperCamelCase		=     {
				    '''task_specific_params.summarization.length_penalty''': 1.0,
				    '''task_specific_params.summarization.max_length''': 128,
				    '''task_specific_params.summarization.min_length''': 12,
				    '''task_specific_params.summarization.num_beams''': 4,
				    '''task_specific_params.summarization_cnn.length_penalty''': 2.0,
				    '''task_specific_params.summarization_cnn.max_length''': 142,
				    '''task_specific_params.summarization_cnn.min_length''': 56,
				    '''task_specific_params.summarization_cnn.num_beams''': 4,
				    '''task_specific_params.summarization_xsum.length_penalty''': 1.0,
				    '''task_specific_params.summarization_xsum.max_length''': 62,
				    '''task_specific_params.summarization_xsum.min_length''': 11,
				    '''task_specific_params.summarization_xsum.num_beams''': 6,
				}

				self.assertEqual(flatten_dict(lowercase_       )				,      lowercase_       )



		def __UpperCamelCase ( self       )  ->					int:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(3				,      4       )
				self.assertTrue(np.allclose(transpose(lowercase_       )				,      x.transpose()       )       )

				UpperCamelCase		=     np.random.randn(3				,      4				,      5       )
				self.assertTrue(np.allclose(transpose(lowercase_				,      axes=(1, 2, 0)       )				,      x.transpose((1, 2, 0)       )       )       )



		@require_torch
		def __UpperCamelCase ( self       )  ->					int:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(3				,      4       )
				UpperCamelCase		=     torch.tensor(lowercase_       )
				self.assertTrue(np.allclose(transpose(lowercase_       )				,      transpose(lowercase_       ).numpy()       )       )

				UpperCamelCase		=     np.random.randn(3				,      4				,      5       )
				UpperCamelCase		=     torch.tensor(lowercase_       )
				self.assertTrue(np.allclose(transpose(lowercase_				,      axes=(1, 2, 0)       )				,      transpose(lowercase_				,      axes=(1, 2, 0)       ).numpy()       )       )



		@require_tf
		def __UpperCamelCase ( self       )  ->					Optional[Any]:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(3				,      4       )
				UpperCamelCase		=     tf.constant(lowercase_       )
				self.assertTrue(np.allclose(transpose(lowercase_       )				,      transpose(lowercase_       ).numpy()       )       )

				UpperCamelCase		=     np.random.randn(3				,      4				,      5       )
				UpperCamelCase		=     tf.constant(lowercase_       )
				self.assertTrue(np.allclose(transpose(lowercase_				,      axes=(1, 2, 0)       )				,      transpose(lowercase_				,      axes=(1, 2, 0)       ).numpy()       )       )



		@require_flax
		def __UpperCamelCase ( self       )  ->					str:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(3				,      4       )
				UpperCamelCase		=     jnp.array(lowercase_       )
				self.assertTrue(np.allclose(transpose(lowercase_       )				,      np.asarray(transpose(lowercase_       )       )       )       )

				UpperCamelCase		=     np.random.randn(3				,      4				,      5       )
				UpperCamelCase		=     jnp.array(lowercase_       )
				self.assertTrue(np.allclose(transpose(lowercase_				,      axes=(1, 2, 0)       )				,      np.asarray(transpose(lowercase_				,      axes=(1, 2, 0)       )       )       )       )



		def __UpperCamelCase ( self       )  ->					str:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(3				,      4       )
				self.assertTrue(np.allclose(reshape(lowercase_				,      (4, 3)       )				,      np.reshape(lowercase_				,      (4, 3)       )       )       )

				UpperCamelCase		=     np.random.randn(3				,      4				,      5       )
				self.assertTrue(np.allclose(reshape(lowercase_				,      (12, 5)       )				,      np.reshape(lowercase_				,      (12, 5)       )       )       )



		@require_torch
		def __UpperCamelCase ( self       )  ->					List[Any]:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(3				,      4       )
				UpperCamelCase		=     torch.tensor(lowercase_       )
				self.assertTrue(np.allclose(reshape(lowercase_				,      (4, 3)       )				,      reshape(lowercase_				,      (4, 3)       ).numpy()       )       )

				UpperCamelCase		=     np.random.randn(3				,      4				,      5       )
				UpperCamelCase		=     torch.tensor(lowercase_       )
				self.assertTrue(np.allclose(reshape(lowercase_				,      (12, 5)       )				,      reshape(lowercase_				,      (12, 5)       ).numpy()       )       )



		@require_tf
		def __UpperCamelCase ( self       )  ->					int:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(3				,      4       )
				UpperCamelCase		=     tf.constant(lowercase_       )
				self.assertTrue(np.allclose(reshape(lowercase_				,      (4, 3)       )				,      reshape(lowercase_				,      (4, 3)       ).numpy()       )       )

				UpperCamelCase		=     np.random.randn(3				,      4				,      5       )
				UpperCamelCase		=     tf.constant(lowercase_       )
				self.assertTrue(np.allclose(reshape(lowercase_				,      (12, 5)       )				,      reshape(lowercase_				,      (12, 5)       ).numpy()       )       )



		@require_flax
		def __UpperCamelCase ( self       )  ->					Any:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(3				,      4       )
				UpperCamelCase		=     jnp.array(lowercase_       )
				self.assertTrue(np.allclose(reshape(lowercase_				,      (4, 3)       )				,      np.asarray(reshape(lowercase_				,      (4, 3)       )       )       )       )

				UpperCamelCase		=     np.random.randn(3				,      4				,      5       )
				UpperCamelCase		=     jnp.array(lowercase_       )
				self.assertTrue(np.allclose(reshape(lowercase_				,      (12, 5)       )				,      np.asarray(reshape(lowercase_				,      (12, 5)       )       )       )       )



		def __UpperCamelCase ( self       )  ->					List[Any]:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(1				,      3				,      4       )
				self.assertTrue(np.allclose(squeeze(lowercase_       )				,      np.squeeze(lowercase_       )       )       )

				UpperCamelCase		=     np.random.randn(1				,      4				,      1				,      5       )
				self.assertTrue(np.allclose(squeeze(lowercase_				,      axis=2       )				,      np.squeeze(lowercase_				,      axis=2       )       )       )



		@require_torch
		def __UpperCamelCase ( self       )  ->					Any:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(1				,      3				,      4       )
				UpperCamelCase		=     torch.tensor(lowercase_       )
				self.assertTrue(np.allclose(squeeze(lowercase_       )				,      squeeze(lowercase_       ).numpy()       )       )

				UpperCamelCase		=     np.random.randn(1				,      4				,      1				,      5       )
				UpperCamelCase		=     torch.tensor(lowercase_       )
				self.assertTrue(np.allclose(squeeze(lowercase_				,      axis=2       )				,      squeeze(lowercase_				,      axis=2       ).numpy()       )       )



		@require_tf
		def __UpperCamelCase ( self       )  ->					List[str]:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(1				,      3				,      4       )
				UpperCamelCase		=     tf.constant(lowercase_       )
				self.assertTrue(np.allclose(squeeze(lowercase_       )				,      squeeze(lowercase_       ).numpy()       )       )

				UpperCamelCase		=     np.random.randn(1				,      4				,      1				,      5       )
				UpperCamelCase		=     tf.constant(lowercase_       )
				self.assertTrue(np.allclose(squeeze(lowercase_				,      axis=2       )				,      squeeze(lowercase_				,      axis=2       ).numpy()       )       )



		@require_flax
		def __UpperCamelCase ( self       )  ->					Tuple:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(1				,      3				,      4       )
				UpperCamelCase		=     jnp.array(lowercase_       )
				self.assertTrue(np.allclose(squeeze(lowercase_       )				,      np.asarray(squeeze(lowercase_       )       )       )       )

				UpperCamelCase		=     np.random.randn(1				,      4				,      1				,      5       )
				UpperCamelCase		=     jnp.array(lowercase_       )
				self.assertTrue(np.allclose(squeeze(lowercase_				,      axis=2       )				,      np.asarray(squeeze(lowercase_				,      axis=2       )       )       )       )



		def __UpperCamelCase ( self       )  ->					Optional[Any]:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(3				,      4       )
				self.assertTrue(np.allclose(expand_dims(lowercase_				,      axis=1       )				,      np.expand_dims(lowercase_				,      axis=1       )       )       )



		@require_torch
		def __UpperCamelCase ( self       )  ->					str:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(3				,      4       )
				UpperCamelCase		=     torch.tensor(lowercase_       )
				self.assertTrue(np.allclose(expand_dims(lowercase_				,      axis=1       )				,      expand_dims(lowercase_				,      axis=1       ).numpy()       )       )



		@require_tf
		def __UpperCamelCase ( self       )  ->					List[Any]:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(3				,      4       )
				UpperCamelCase		=     tf.constant(lowercase_       )
				self.assertTrue(np.allclose(expand_dims(lowercase_				,      axis=1       )				,      expand_dims(lowercase_				,      axis=1       ).numpy()       )       )



		@require_flax
		def __UpperCamelCase ( self       )  ->					Tuple:
				"""simple docstring"""
				UpperCamelCase		=     np.random.randn(3				,      4       )
				UpperCamelCase		=     jnp.array(lowercase_       )
				self.assertTrue(np.allclose(expand_dims(lowercase_				,      axis=1       )				,      np.asarray(expand_dims(lowercase_				,      axis=1       )       )       )       )








"""simple docstring"""






from math import factorial



def 					_A			(__a = 20							) ->       int:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_      :  Dict    						=		2 * n  # middle entry of odd rows starting at row 3 is the solution for n = 1,
    # 2, 3,...
    SCREAMING_SNAKE_CASE_      :  List[str]    						=		n // 2

    return int(factorial(__a							) / (factorial(__a							) * factorial(n - k							))							)


if __name__ == "__main__":
  import sys

  if len(sys.argv) == 1:
    print(solution(20))
  else:
    try:
      UpperCAmelCase_   : List[str]   			= int(sys.argv[1])
      print(solution(n))
    except ValueError:
      print("""Invalid entry - please enter a number.""")


