





from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase_     							= logging.get_logger(__name__)

UpperCAmelCase_     							= {
    'EleutherAI/gpt-neox-20b': 'https://huggingface.co/EleutherAI/gpt-neox-20b/resolve/main/config.json',
    # See all GPTNeoX models at https://huggingface.co/models?filter=gpt_neox
}






class     lowercase__       (	__lowerCamelCase				):

   '''simple docstring'''


   a						:							Tuple   		=		"gpt_neox"




   def __init__(    self,		__magic_name__=50432,		__magic_name__=6144,		__magic_name__=44,		__magic_name__=64,		__magic_name__=24576,		__magic_name__="gelu",		__magic_name__=0.25,		__magic_name__=10000,		__magic_name__=0.0,		__magic_name__=0.0,		__magic_name__=0.1,		__magic_name__=2048,		__magic_name__=0.02,		__magic_name__=1E-5,		__magic_name__=True,		__magic_name__=0,		__magic_name__=2,		__magic_name__=False,		__magic_name__=True,		__magic_name__=None,		**__magic_name__,		) ->      List[Any]:






       """simple docstring"""
       super().__init__(bos_token_id=__magic_name__,		eos_token_id=__magic_name__,		**__magic_name__							)
       UpperCamelCase__							:				str          =      vocab_size
       UpperCamelCase__							:				Optional[Any]          =      max_position_embeddings
       UpperCamelCase__							:				Optional[Any]          =      hidden_size
       UpperCamelCase__							:				int          =      num_hidden_layers
       UpperCamelCase__							:				List[Any]          =      num_attention_heads
       UpperCamelCase__							:				int          =      intermediate_size
       UpperCamelCase__							:				Optional[int]          =      hidden_act
       UpperCamelCase__							:				Optional[Any]          =      rotary_pct
       UpperCamelCase__							:				Tuple          =      rotary_emb_base
       UpperCamelCase__							:				Any          =      attention_dropout
       UpperCamelCase__							:				Optional[Any]          =      hidden_dropout
       UpperCamelCase__							:				str          =      classifier_dropout
       UpperCamelCase__							:				int          =      initializer_range
       UpperCamelCase__							:				List[str]          =      layer_norm_eps
       UpperCamelCase__							:				List[str]          =      use_cache
       UpperCamelCase__							:				Dict          =      tie_word_embeddings
       UpperCamelCase__							:				List[str]          =      use_parallel_residual
       UpperCamelCase__							:				str          =      rope_scaling
       self._rope_scaling_validation()

       if self.hidden_size % self.num_attention_heads != 0:
           raise ValueError(
               '''The hidden size is not divisble by the number of attention heads! Make sure to update them!'''							)




   def       UpperCamelCase__  (    self							) ->      Union[str, Any]:






       """simple docstring"""
       if self.rope_scaling is None:
           return

       if not isinstance(self.rope_scaling,		__magic_name__							) or len(self.rope_scaling							) != 2:
           raise ValueError(
               '''`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, '''
               f"got {self.rope_scaling}"							)
       UpperCamelCase__							:				str          =      self.rope_scaling.get('''type''',		__magic_name__							)
       UpperCamelCase__							:				Union[str, Any]          =      self.rope_scaling.get('''factor''',		__magic_name__							)
       if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]:
           raise ValueError(
               f"`rope_scaling`'s name field must be one of ['linear', 'dynamic'], got {rope_scaling_type}"							)
       if rope_scaling_factor is None or not isinstance(__magic_name__,		__magic_name__							) or rope_scaling_factor <= 1.0:
           raise ValueError(f"`rope_scaling`'s factor field must be an float > 1, got {rope_scaling_factor}"							)








from __future__ import annotations




def 		lowerCAmelCase_    (  __UpperCAmelCase:			int		,   __UpperCAmelCase:			int      )      ->	list[list[int]]:
    UpperCamelCase__							:				list[list[int]]          =      []
    create_all_state(1		,   __UpperCAmelCase		,   __UpperCAmelCase		,   []		,   __UpperCAmelCase      )
    return result




def 		lowerCAmelCase_    (  __UpperCAmelCase:			int		,   __UpperCAmelCase:			int		,   __UpperCAmelCase:			int		,   __UpperCAmelCase:			list[int]		,   __UpperCAmelCase:			list[list[int]]		,   )      ->	None:
    if level == 0:
        total_list.append(current_list[:]      )
        return

    for i in range(__UpperCAmelCase		,   total_number - level + 2      ):
        current_list.append(__UpperCAmelCase      )
        create_all_state(i + 1		,   __UpperCAmelCase		,   level - 1		,   __UpperCAmelCase		,   __UpperCAmelCase      )
        current_list.pop()




def 		lowerCAmelCase_    (  __UpperCAmelCase:			list[list[int]]      )      ->	None:
    for i in total_list:
        print(*__UpperCAmelCase      )


if __name__ == "__main__":
  UpperCAmelCase_     							= 4
  UpperCAmelCase_     							= 2
  UpperCAmelCase_     							= generate_all_combinations(n, k)
  print_all_state(total_list)

