






from abc import ABC, abstractmethod
from typing import List, Optional
class  lowerCAmelCase_       (				__a					):




							def __init__(   self     :   List[Any]	):
											# test for the above condition
											self.test()




							def 						__snake_case					(   self     :   int	):
											lowerCAmelCase__      			=						0
											lowerCAmelCase__      			=						False
											while not completed:
															if counter == 1:
																			self.reset()
															lowerCAmelCase__      			=						self.advance()
															if not self.does_advance(A__	):
																			raise Exception(
																			    '''Custom Constraint is not defined correctly. self.does_advance(self.advance()) must be true.'''	)

															lowerCAmelCase__			,		lowerCAmelCase__			,		lowerCAmelCase__      			=						self.update(A__	)
															counter += 1

															if counter > 10_000:
																			raise Exception('''update() does not fulfill the constraint.'''	)

											if self.remaining() != 0:
															raise Exception('''Custom Constraint is not defined correctly.'''	)




							@abstractmethod
							def 						__snake_case					(   self     :   str	):
											raise NotImplementedError(
											    f'{self.__class__} is an abstract class. Only classes inheriting this class can be called.'	)




							@abstractmethod
							def 						__snake_case					(   self     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   Tuple	):
											raise NotImplementedError(
											    f'{self.__class__} is an abstract class. Only classes inheriting this class can be called.'	)




							@abstractmethod
							def 						__snake_case					(   self     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   Optional[Any]	):
											raise NotImplementedError(
											    f'{self.__class__} is an abstract class. Only classes inheriting this class can be called.'	)




							@abstractmethod
							def 						__snake_case					(   self     :   Optional[int]	):
											raise NotImplementedError(
											    f'{self.__class__} is an abstract class. Only classes inheriting this class can be called.'	)




							@abstractmethod
							def 						__snake_case					(   self     :   Optional[int]	):
											raise NotImplementedError(
											    f'{self.__class__} is an abstract class. Only classes inheriting this class can be called.'	)




							@abstractmethod
							def 						__snake_case					(   self     :   Optional[int] ,							SCREAMING_SNAKE_CASE_     :   int=False	):
											raise NotImplementedError(
											    f'{self.__class__} is an abstract class. Only classes inheriting this class can be called.'	)



class  lowerCAmelCase_       (				__a					):




							def __init__(   self     :   Dict ,							SCREAMING_SNAKE_CASE_     :   List[Any]	):
											super(A__ ,							self	).__init__()

											if not isinstance(A__ ,							A__	) or len(A__	) == 0:
															raise ValueError(f'`token_ids` has to be a non-empty list, but is {token_ids}.'	)
											if any((not isinstance(A__ ,							A__	) or token_id < 0) for token_id in token_ids	):
															raise ValueError(f'Each list in `token_ids` has to be a list of positive integers, but is {token_ids}.'	)

											lowerCAmelCase__      			=						token_ids

											lowerCAmelCase__      			=						len(self.token_ids	)
											lowerCAmelCase__      			=						-1  # the index of the currently fulfilled step
											lowerCAmelCase__      			=						False




							def 						__snake_case					(   self     :   Tuple	):
											if self.completed:
															return None
											return self.token_ids[self.fulfilled_idx + 1]




							def 						__snake_case					(   self     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any]	):
											if not isinstance(A__ ,							A__	):
															raise ValueError(f'`token_id` has to be an `int`, but is {token_id} of type {type(A__	)}'	)

											if self.completed:
															return False

											return token_id == self.token_ids[self.fulfilled_idx + 1]




							def 						__snake_case					(   self     :   List[str] ,							SCREAMING_SNAKE_CASE_     :   List[str]	):
											if not isinstance(A__ ,							A__	):
															raise ValueError(f'`token_id` has to be an `int`, but is {token_id} of type {type(A__	)}'	)

											lowerCAmelCase__      			=						False
											lowerCAmelCase__      			=						False
											lowerCAmelCase__      			=						False

											if self.does_advance(A__	):
															self.fulfilled_idx += 1
															lowerCAmelCase__      			=						True
															if self.fulfilled_idx == (self.seqlen - 1):
																			lowerCAmelCase__      			=						True
															lowerCAmelCase__      			=						completed
											else:
															# failed to make progress.
															lowerCAmelCase__      			=						True
															self.reset()
											return stepped, completed, reset




							def 						__snake_case					(   self     :   List[Any]	):
											lowerCAmelCase__      			=						False
											lowerCAmelCase__      			=						0




							def 						__snake_case					(   self     :   str	):
											return self.seqlen - (self.fulfilled_idx + 1)




							def 						__snake_case					(   self     :   Dict ,							SCREAMING_SNAKE_CASE_     :   Dict=False	):
											lowerCAmelCase__      			=						PhrasalConstraint(self.token_ids	)

											if stateful:
															lowerCAmelCase__      			=						self.seqlen
															lowerCAmelCase__      			=						self.fulfilled_idx
															lowerCAmelCase__      			=						self.completed

											return new_constraint



class  lowerCAmelCase_       :




							def __init__(   self     :   List[str] ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   int=True	):
											lowerCAmelCase__      			=						max([len(A__	) for one in nested_token_ids]	)

											lowerCAmelCase__      			=						{}
											for token_ids in nested_token_ids:
															lowerCAmelCase__      			=						root
															for tidx, token_id in enumerate(A__	):
																			if token_id not in level:
																							lowerCAmelCase__      			=						{}

																			lowerCAmelCase__      			=						level[token_id]

											if no_subsets and self.has_subsets(A__ ,							A__	):
															raise ValueError(
															    '''Each list in `nested_token_ids` can\'t be a complete subset of another list, but is'''
															    f' {nested_token_ids}.'	)

											lowerCAmelCase__      			=						root




							def 						__snake_case					(   self     :   Optional[int] ,							SCREAMING_SNAKE_CASE_     :   str	):
											lowerCAmelCase__      			=						self.trie

											for current_token in current_seq:
															lowerCAmelCase__      			=						start[current_token]

											lowerCAmelCase__      			=						list(start.keys()	)

											return next_tokens




							def 						__snake_case					(   self     :   str ,							SCREAMING_SNAKE_CASE_     :   Tuple	):
											lowerCAmelCase__      			=						self.next_tokens(A__	)

											return len(A__	) == 0




							def 						__snake_case					(   self     :   Dict ,							SCREAMING_SNAKE_CASE_     :   int	):
											lowerCAmelCase__      			=						list(root.values()	)
											if len(A__	) == 0:
															return 1
											else:
															return sum([self.count_leaves(A__	) for nn in next_nodes]	)




							def 						__snake_case					(   self     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   Optional[int] ,							SCREAMING_SNAKE_CASE_     :   List[str]	):
											lowerCAmelCase__      			=						self.count_leaves(A__	)
											return len(A__	) != leaf_count



class  lowerCAmelCase_       (				__a					):




							def __init__(   self     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   Any	):
											super(A__ ,							self	).__init__()

											if not isinstance(A__ ,							A__	) or len(A__	) == 0:
															raise ValueError(f'`nested_token_ids` has to be a non-empty list, but is {nested_token_ids}.'	)
											if any(not isinstance(A__ ,							A__	) for token_ids in nested_token_ids	):
															raise ValueError(f'`nested_token_ids` has to be a list of lists, but is {nested_token_ids}.'	)
											if any(
											    any((not isinstance(A__ ,							A__	) or token_id < 0) for token_id in token_ids	)
											    for token_ids in nested_token_ids	):
															raise ValueError(
															    f'Each list in `nested_token_ids` has to be a list of positive integers, but is {nested_token_ids}.'	)

											lowerCAmelCase__      			=						DisjunctiveTrie(A__	)
											lowerCAmelCase__      			=						nested_token_ids

											lowerCAmelCase__      			=						self.trie.max_height
											lowerCAmelCase__      			=						[]
											lowerCAmelCase__      			=						False




							def 						__snake_case					(   self     :   str	):
											lowerCAmelCase__      			=						self.trie.next_tokens(self.current_seq	)

											if len(A__	) == 0:
															return None
											else:
															return token_list




							def 						__snake_case					(   self     :   int ,							SCREAMING_SNAKE_CASE_     :   Any	):
											if not isinstance(A__ ,							A__	):
															raise ValueError(f'`token_id` is supposed to be type `int`, but is {token_id} of type {type(A__	)}'	)

											lowerCAmelCase__      			=						self.trie.next_tokens(self.current_seq	)

											return token_id in next_tokens




							def 						__snake_case					(   self     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any]	):
											if not isinstance(A__ ,							A__	):
															raise ValueError(f'`token_id` is supposed to be type `int`, but is {token_id} of type {type(A__	)}'	)

											lowerCAmelCase__      			=						False
											lowerCAmelCase__      			=						False
											lowerCAmelCase__      			=						False

											if self.does_advance(A__	):
															self.current_seq.append(A__	)
															lowerCAmelCase__      			=						True
											else:
															lowerCAmelCase__      			=						True
															self.reset()

											lowerCAmelCase__      			=						self.trie.reached_leaf(self.current_seq	)
											lowerCAmelCase__      			=						completed

											return stepped, completed, reset




							def 						__snake_case					(   self     :   Dict	):
											lowerCAmelCase__      			=						False
											lowerCAmelCase__      			=						[]




							def 						__snake_case					(   self     :   str	):
											if self.completed:
															# since this can be completed without reaching max height
															return 0
											else:
															return self.seqlen - len(self.current_seq	)




							def 						__snake_case					(   self     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   int=False	):
											lowerCAmelCase__      			=						DisjunctiveConstraint(self.token_ids	)

											if stateful:
															lowerCAmelCase__      			=						self.seqlen
															lowerCAmelCase__      			=						self.current_seq
															lowerCAmelCase__      			=						self.completed

											return new_constraint



class  lowerCAmelCase_       :




							def __init__(   self     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   Optional[int]	):
											lowerCAmelCase__      			=						constraints

											# max # of steps required to fulfill a given constraint
											lowerCAmelCase__      			=						max([c.seqlen for c in constraints]	)
											lowerCAmelCase__      			=						len(A__	)
											lowerCAmelCase__      			=						False

											self.init_state()




							def 						__snake_case					(   self     :   str	):
											lowerCAmelCase__      			=						[]
											lowerCAmelCase__      			=						None
											lowerCAmelCase__      			=						[constraint.copy(stateful=A__	) for constraint in self.constraints]




							def 						__snake_case					(   self     :   Optional[Any]	):
											lowerCAmelCase__      			=						0
											if self.inprogress_constraint:
															# extra points for having a constraint mid-fulfilled
															add += self.max_seqlen - self.inprogress_constraint.remaining()

											return (len(self.complete_constraints	) * self.max_seqlen) + add




							def 						__snake_case					(   self     :   Dict	):
											lowerCAmelCase__      			=						[]
											if self.inprogress_constraint is None:
															for constraint in self.pending_constraints:  # "pending" == "unfulfilled yet"
																			lowerCAmelCase__      			=						constraint.advance()
																			if isinstance(A__ ,							A__	):
																							token_list.append(A__	)
																			elif isinstance(A__ ,							A__	):
																							token_list.extend(A__	)
											else:
															lowerCAmelCase__      			=						self.inprogress_constraint.advance()
															if isinstance(A__ ,							A__	):
																			token_list.append(A__	)
															elif isinstance(A__ ,							A__	):
																			token_list.extend(A__	)

											if len(A__	) == 0:
															return None
											else:
															return token_list




							def 						__snake_case					(   self     :   int ,							SCREAMING_SNAKE_CASE_     :   Any	):
											self.init_state()

											if token_ids is not None:
															for token in token_ids:
																			# completes or steps **one** constraint
																			lowerCAmelCase__			,		lowerCAmelCase__      			=						self.add(A__	)

																			# the entire list of constraints are fulfilled
																			if self.completed:
																							break




							def 						__snake_case					(   self     :   int ,							SCREAMING_SNAKE_CASE_     :   Optional[int]	):
											if not isinstance(A__ ,							A__	):
															raise ValueError(f'`token_id` should be an `int`, but is `{token_id}`.'	)

											lowerCAmelCase__			,		lowerCAmelCase__      			=						False, False

											if self.completed:
															lowerCAmelCase__      			=						True
															lowerCAmelCase__      			=						False
															return complete, stepped

											if self.inprogress_constraint is not None:
															# In the middle of fulfilling a constraint. If the `token_id` *does* makes an incremental progress to current
															# job, simply update the state

															lowerCAmelCase__			,		lowerCAmelCase__			,		lowerCAmelCase__      			=						self.inprogress_constraint.update(A__	)
															if reset:
																			# 1. If the next token breaks the progress, then we must restart.
																			#     e.g. constraint = "I love pies" and sequence so far is "I love" but `token_id` == "books".

																			#     But that doesn't mean we self.init_state(), since we only reset the state for this particular
																			#     constraint, not the full list of constraints.

																			self.pending_constraints.append(self.inprogress_constraint.copy(stateful=A__	)	)
																			lowerCAmelCase__      			=						None

															if complete:
																			# 2. If the next token completes the constraint, move it to completed list, set
																			#     inprogress to None. If there are no pending constraints either, then this full list of constraints
																			#     is complete.

																			self.complete_constraints.append(self.inprogress_constraint	)
																			lowerCAmelCase__      			=						None

																			if len(self.pending_constraints	) == 0:
																							# we're done!
																							lowerCAmelCase__      			=						True

											else:
															# Not in the middle of fulfilling a constraint. So does this `token_id` helps us step towards any of our list
															# of constraints?

															for cidx, pending_constraint in enumerate(self.pending_constraints	):
																			if pending_constraint.does_advance(A__	):
																							lowerCAmelCase__			,		lowerCAmelCase__			,		lowerCAmelCase__      			=						pending_constraint.update(A__	)

																							if not stepped:
																											raise Exception(
																											    '''`constraint.update(token_id)` is not yielding incremental progress, '''
																											    '''even though `constraint.does_advance(token_id)` is true.'''	)

																							if complete:
																											self.complete_constraints.append(A__	)
																											lowerCAmelCase__      			=						None

																							if not complete and stepped:
																											lowerCAmelCase__      			=						pending_constraint

																							if complete or stepped:
																											# If we made any progress at all, then it's at least not a "pending constraint".

																											lowerCAmelCase__      			=						(
																											    self.pending_constraints[:cidx] + self.pending_constraints[cidx + 1 :]
																											)

																											if len(self.pending_constraints	) == 0 and self.inprogress_constraint is None:
																															# If there's no longer any pending after this and no inprogress either, then we must be
																															# complete.

																															lowerCAmelCase__      			=						True

																											break  # prevent accidentally stepping through multiple constraints with just one token.

											return complete, stepped




							def 						__snake_case					(   self     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   str=True	):
											lowerCAmelCase__      			=						ConstraintListState(self.constraints	)  # we actually never though self.constraints objects
											# throughout this process. So it's at initialization state.

											if stateful:
															lowerCAmelCase__      			=						[
															    constraint.copy(stateful=A__	) for constraint in self.complete_constraints
															]
															if self.inprogress_constraint is not None:
																			lowerCAmelCase__      			=						self.inprogress_constraint.copy(stateful=A__	)
															lowerCAmelCase__      			=						[constraint.copy() for constraint in self.pending_constraints]

											return new_state













from collections import OrderedDict
from typing import Any, List, Mapping, Optional

from ... import PreTrainedTokenizer, TensorType, is_torch_available
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import logging


_UpperCAmelCase			:		Tuple   				=    logging.get_logger(__name__)


_UpperCAmelCase			:		int   				=    {
    "Salesforce/codegen-350M-nl": "https://huggingface.co/Salesforce/codegen-350M-nl/resolve/main/config.json",
    "Salesforce/codegen-350M-multi": "https://huggingface.co/Salesforce/codegen-350M-multi/resolve/main/config.json",
    "Salesforce/codegen-350M-mono": "https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/config.json",
    "Salesforce/codegen-2B-nl": "https://huggingface.co/Salesforce/codegen-2B-nl/resolve/main/config.json",
    "Salesforce/codegen-2B-multi": "https://huggingface.co/Salesforce/codegen-2B-multi/resolve/main/config.json",
    "Salesforce/codegen-2B-mono": "https://huggingface.co/Salesforce/codegen-2B-mono/resolve/main/config.json",
    "Salesforce/codegen-6B-nl": "https://huggingface.co/Salesforce/codegen-6B-nl/resolve/main/config.json",
    "Salesforce/codegen-6B-multi": "https://huggingface.co/Salesforce/codegen-6B-multi/resolve/main/config.json",
    "Salesforce/codegen-6B-mono": "https://huggingface.co/Salesforce/codegen-6B-mono/resolve/main/config.json",
    "Salesforce/codegen-16B-nl": "https://huggingface.co/Salesforce/codegen-16B-nl/resolve/main/config.json",
    "Salesforce/codegen-16B-multi": "https://huggingface.co/Salesforce/codegen-16B-multi/resolve/main/config.json",
    "Salesforce/codegen-16B-mono": "https://huggingface.co/Salesforce/codegen-16B-mono/resolve/main/config.json",
}
class  lowerCAmelCase_       (				snake_case__					):
							UpperCamelCase_		:int		      =    'codegen'
							UpperCamelCase_		:int		      =    {
							    'max_position_embeddings': 'n_positions',
							    'hidden_size': 'n_embd',
							    'num_attention_heads': 'n_head',
							    'num_hidden_layers': 'n_layer',
							}




							def __init__(   self     :   Optional[int] ,							SCREAMING_SNAKE_CASE_     :   str=50_400 ,							SCREAMING_SNAKE_CASE_     :   str=2_048 ,							SCREAMING_SNAKE_CASE_     :   int=2_048 ,							SCREAMING_SNAKE_CASE_     :   Any=4_096 ,							SCREAMING_SNAKE_CASE_     :   List[Any]=28 ,							SCREAMING_SNAKE_CASE_     :   str=16 ,							SCREAMING_SNAKE_CASE_     :   str=64 ,							SCREAMING_SNAKE_CASE_     :   Tuple=None ,							SCREAMING_SNAKE_CASE_     :   Dict="gelu_new" ,							SCREAMING_SNAKE_CASE_     :   str=0.0 ,							SCREAMING_SNAKE_CASE_     :   Any=0.0 ,							SCREAMING_SNAKE_CASE_     :   Any=0.0 ,							SCREAMING_SNAKE_CASE_     :   Any=1e-5 ,							SCREAMING_SNAKE_CASE_     :   Any=0.02 ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any]=True ,							SCREAMING_SNAKE_CASE_     :   Optional[int]=50_256 ,							SCREAMING_SNAKE_CASE_     :   Any=50_256 ,							SCREAMING_SNAKE_CASE_     :   List[str]=False ,							**SCREAMING_SNAKE_CASE_     :   Union[str, Any] ,							):
											lowerCAmelCase__      			=						vocab_size
											lowerCAmelCase__      			=						n_ctx
											lowerCAmelCase__      			=						n_positions
											lowerCAmelCase__      			=						n_embd
											lowerCAmelCase__      			=						n_layer
											lowerCAmelCase__      			=						n_head
											lowerCAmelCase__      			=						n_inner
											lowerCAmelCase__      			=						rotary_dim
											lowerCAmelCase__      			=						activation_function
											lowerCAmelCase__      			=						resid_pdrop
											lowerCAmelCase__      			=						embd_pdrop
											lowerCAmelCase__      			=						attn_pdrop
											lowerCAmelCase__      			=						layer_norm_epsilon
											lowerCAmelCase__      			=						initializer_range
											lowerCAmelCase__      			=						use_cache

											lowerCAmelCase__      			=						bos_token_id
											lowerCAmelCase__      			=						eos_token_id

											super().__init__(
											    bos_token_id=SCREAMING_SNAKE_CASE_ ,							eos_token_id=SCREAMING_SNAKE_CASE_ ,							tie_word_embeddings=SCREAMING_SNAKE_CASE_ ,							**SCREAMING_SNAKE_CASE_	)



class  lowerCAmelCase_       (				snake_case__					):




							def __init__(   self     :   str ,							SCREAMING_SNAKE_CASE_     :   PretrainedConfig ,							SCREAMING_SNAKE_CASE_     :   str = "default" ,							SCREAMING_SNAKE_CASE_     :   List[PatchingSpec] = None ,							SCREAMING_SNAKE_CASE_     :   bool = False ,							):
											super().__init__(SCREAMING_SNAKE_CASE_ ,							task=SCREAMING_SNAKE_CASE_ ,							patching_specs=SCREAMING_SNAKE_CASE_ ,							use_past=SCREAMING_SNAKE_CASE_	)
											if not getattr(self._config ,							'''pad_token_id''' ,							SCREAMING_SNAKE_CASE_	):
															# TODO: how to do that better?
															lowerCAmelCase__      			=						0




							@property
							def 						__snake_case					(   self     :   str	):
											lowerCAmelCase__      			=						OrderedDict({'''input_ids''': {0: '''batch''', 1: '''sequence'''}}	)
											if self.use_past:
															self.fill_with_past_key_values_(SCREAMING_SNAKE_CASE_ ,							direction='''inputs'''	)
															lowerCAmelCase__      			=						{0: '''batch''', 1: '''past_sequence + sequence'''}
											else:
															lowerCAmelCase__      			=						{0: '''batch''', 1: '''sequence'''}

											return common_inputs




							@property
							def 						__snake_case					(   self     :   Dict	):
											return self._config.n_layer




							@property
							def 						__snake_case					(   self     :   Union[str, Any]	):
											return self._config.n_head




							def 						__snake_case					(   self     :   Optional[Any] ,							SCREAMING_SNAKE_CASE_     :   PreTrainedTokenizer ,							SCREAMING_SNAKE_CASE_     :   int = -1 ,							SCREAMING_SNAKE_CASE_     :   int = -1 ,							SCREAMING_SNAKE_CASE_     :   bool = False ,							SCREAMING_SNAKE_CASE_     :   Optional[TensorType] = None ,							):
											lowerCAmelCase__      			=						super(SCREAMING_SNAKE_CASE_ ,							self	).generate_dummy_inputs(
											    SCREAMING_SNAKE_CASE_ ,							batch_size=SCREAMING_SNAKE_CASE_ ,							seq_length=SCREAMING_SNAKE_CASE_ ,							is_pair=SCREAMING_SNAKE_CASE_ ,							framework=SCREAMING_SNAKE_CASE_	)

											# We need to order the input in the way they appears in the forward()
											lowerCAmelCase__      			=						OrderedDict({'''input_ids''': common_inputs['''input_ids''']}	)

											# Need to add the past_keys
											if self.use_past:
															if not is_torch_available():
																			raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''	)
															else:
																			import torch

																			lowerCAmelCase__			,		lowerCAmelCase__      			=						common_inputs['''input_ids'''].shape
																			# Not using the same length for past_key_values
																			lowerCAmelCase__      			=						seqlen + 2
																			lowerCAmelCase__      			=						(
																			    batch,
																			    self.num_attention_heads,
																			    past_key_values_length,
																			    self._config.hidden_size // self.num_attention_heads,
																			)
																			lowerCAmelCase__      			=						[
																			    (torch.zeros(SCREAMING_SNAKE_CASE_	), torch.zeros(SCREAMING_SNAKE_CASE_	)) for _ in range(self.num_layers	)
																			]

											lowerCAmelCase__      			=						common_inputs['''attention_mask''']
											if self.use_past:
															lowerCAmelCase__      			=						ordered_inputs['''attention_mask'''].dtype
															lowerCAmelCase__      			=						torch.cat(
															    [ordered_inputs['''attention_mask'''], torch.ones(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							dtype=SCREAMING_SNAKE_CASE_	)] ,							dim=1	)

											return ordered_inputs




							@property
							def 						__snake_case					(   self     :   Optional[int]	):
											return 13





