
def 	UpperCamelCase   (							lowerCAmelCase__		):
					'''simple docstring'''
					if upper_limit < 0:
										raise ValueError('''Limit for the Catalan sequence must be ≥ 0'''		)

					lowercase						     =						[0] * (upper_limit + 1)

					# Base case: C(0) = C(1) = 1
					lowercase						     =						1
					if upper_limit > 0:
										lowercase						     =						1

					# Recurrence relation: C(i) = sum(C(j).C(i-j-1)), from j = 0 to i
					for i in range(2			,      upper_limit + 1		):
										for j in range(lowerCAmelCase__		):
															catalan_list[i] += catalan_list[j] * catalan_list[i - j - 1]

					return catalan_list


if __name__ == "__main__":
							print("\n********* Catalan Numbers Using Dynamic Programming ************\n")
							print("\n*** Enter -1 at any time to quit ***")
							print("\nEnter the upper limit (≥ 0) for the Catalan number sequence: ", end="")
							try:
														while True:
																					lowercase__		:int			  =   int(input().strip())
																					if N < 0:
																												print("\n********* Goodbye!! ************")
																												break
																					else:
																												print(F'The Catalan numbers from 0 through {N} are:')
																												print(catalan_numbers(N))
																												print("Try another upper limit for the sequence: ", end="")
							except (NameError, ValueError):
														print("\n********* Invalid input, goodbye! ************\n")

							import doctest

							doctest.testmod()






import unittest

from transformers import TrOCRConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers.models.trocr.modeling_trocr import TrOCRDecoder, TrOCRForCausalLM







@require_torch
class     lowercase		:




							def __init__(    self       ,A__       ,A__=9_9       ,A__=1_3       ,A__=1_6       ,A__=7       ,A__=True       ,A__=True       ,A__=True       ,A__=False       ,A__=True       ,A__=2       ,A__=3_2       ,A__=4       ,A__=4       ,A__=3_0       ,A__=0       ,A__=1       ,A__=2       ,A__=None       ,):
												lowercase						     =						parent
												lowercase						     =						batch_size
												lowercase						     =						decoder_seq_length
												# For common tests
												lowercase						     =						self.decoder_seq_length
												lowercase						     =						is_training
												lowercase						     =						use_attention_mask
												lowercase						     =						use_labels

												lowercase						     =						vocab_size
												lowercase						     =						d_model
												lowercase						     =						d_model
												lowercase						     =						decoder_layers
												lowercase						     =						decoder_layers
												lowercase						     =						decoder_ffn_dim
												lowercase						     =						decoder_attention_heads
												lowercase						     =						decoder_attention_heads
												lowercase						     =						eos_token_id
												lowercase						     =						bos_token_id
												lowercase						     =						pad_token_id
												lowercase						     =						decoder_start_token_id
												lowercase						     =						use_cache
												lowercase						     =						max_position_embeddings

												lowercase						     =						None
												lowercase						     =						decoder_seq_length
												lowercase						     =						2
												lowercase						     =						1




							def 			A__				(    self):
												lowercase						     =						ids_tensor([self.batch_size, self.decoder_seq_length]       ,self.vocab_size)

												lowercase						     =						None
												if self.use_attention_mask:
																	lowercase						     =						ids_tensor([self.batch_size, self.decoder_seq_length]       ,vocab_size=2)

												lowercase						     =						None
												if self.use_labels:
																	lowercase						     =						ids_tensor([self.batch_size, self.decoder_seq_length]       ,self.vocab_size)

												lowercase						     =						TrOCRConfig(
												    vocab_size=self.vocab_size       ,d_model=self.d_model       ,decoder_layers=self.decoder_layers       ,decoder_ffn_dim=self.decoder_ffn_dim       ,decoder_attention_heads=self.decoder_attention_heads       ,eos_token_id=self.eos_token_id       ,bos_token_id=self.bos_token_id       ,use_cache=self.use_cache       ,pad_token_id=self.pad_token_id       ,decoder_start_token_id=self.decoder_start_token_id       ,max_position_embeddings=self.max_position_embeddings       ,)

												return (config, input_ids, attention_mask, lm_labels)




							def 			A__				(    self       ,A__       ,A__       ,A__       ,A__       ,):
												lowercase						     =						True
												lowercase						     =						TrOCRDecoder(config=A__).to(A__).eval()
												lowercase						     =						input_ids[:2]

												input_ids[input_ids == 0] += 1
												# first forward pass
												lowercase						     =						model(A__       ,use_cache=A__)
												lowercase						     =						model(A__)
												lowercase						     =						model(A__       ,use_cache=A__)

												self.parent.assertTrue(len(A__) == len(A__))
												self.parent.assertTrue(len(A__) == len(A__) + 1)

												lowercase						     =						outputs['''past_key_values''']

												# create hypothetical next token and extent to next_input_ids
												lowercase						     =						ids_tensor((2, 1)       ,config.vocab_size - 1) + 1

												# append to next input_ids and
												lowercase						     =						torch.cat([input_ids, next_tokens]       ,dim=-1)

												lowercase						     =						model(A__)['''last_hidden_state''']
												lowercase						     =						model(A__       ,past_key_values=A__)['''last_hidden_state''']

												# select random slice
												lowercase						     =						ids_tensor((1,)       ,output_from_past.shape[-1]).item()
												lowercase						     =						output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
												lowercase						     =						output_from_past[:, 0, random_slice_idx].detach()

												# test that outputs are equal for slice
												assert torch.allclose(A__       ,A__       ,atol=1E-3)





							def 			A__				(    self):
												lowercase						     =						self.prepare_config_and_inputs()
												lowercase     ,						lowercase     ,						lowercase     ,						lowercase						     =						config_and_inputs

												lowercase						     =						{'''input_ids''': input_ids, '''attention_mask''': attention_mask}
												return config, inputs_dict







@require_torch
class     lowercase		( SCREAMING_SNAKE_CASE__	,  SCREAMING_SNAKE_CASE__	,  SCREAMING_SNAKE_CASE__	,  unittest.TestCase		):
							lowercase_	:	Any	 =(TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
							lowercase_	:	Dict	 =(TrOCRForCausalLM,) if is_torch_available() else ()
							lowercase_	:	int	 ={'''text-generation''': TrOCRForCausalLM} if is_torch_available() else {}
							lowercase_	:	List[Any]	 =True
							lowercase_	:	int	 =False




							def 			A__				(    self):
												lowercase						     =						TrOCRStandaloneDecoderModelTester(self       ,is_training=A__)
												lowercase						     =						ConfigTester(self       ,config_class=A__)




							def 			A__				(    self):
												pass




							def 			A__				(    self):
												pass




							def 			A__				(    self):
												pass




							def 			A__				(    self):
												self.config_tester.run_common_tests()




							def 			A__				(    self):
												lowercase						     =						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_decoder_model_past(*A__)




							def 			A__				(    self):
												return





							@unittest.skip('''The model doesn\'t support left padding''')  # and it's not used enough to be worth fixing :)
							def 			A__				(    self):
												pass




