
import logging
import sys
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Union

import librosa
import torch
from datasets import DatasetDict, load_dataset
from packaging import version
from torch import nn

from transformers import (
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaForPreTraining,
    is_apex_available,
    trainer_utils,
)
from transformers.models.wavaveca.modeling_wavaveca import _compute_mask_indices


if is_apex_available():
     from apex import amp

if version.parse(version.parse(torch.__version__).base_version) >= version.parse('''1.6'''):
     __magic_name__            =  True
     from torch.cuda.amp import autocast


__magic_name__            =  logging.getLogger(__name__)




@dataclass
class 					_SCREAMING_SNAKE_CASE  :
      _A						:		str    	=     field(
          metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'} )
      _A						:		Optional[str]    	=     field(
          default=__UpperCamelCase       ,					metadata={'help': 'Where do you want to store the pretrained models downloaded from huggingface.co'}       ,					)
      _A						:		Optional[bool]    	=     field(
          default=__UpperCamelCase       ,					metadata={'help': 'Whether to freeze the feature extractor layers of the model.'} )
      _A						:		Optional[bool]    	=     field(
          default=__UpperCamelCase       ,					metadata={'help': 'Whether to log verbose messages or not.'}       ,					)
      _A						:		Optional[float]    	=     field(
          default=2.0       ,					metadata={'help': 'Maximum temperature for gumbel softmax.'} )
      _A						:		Optional[float]    	=     field(
          default=0.5       ,					metadata={'help': 'Minimum temperature for gumbel softmax.'} )
      _A						:		Optional[float]    	=     field(
          default=0.9_9_9_9_9_5       ,					metadata={'help': 'Decay of gumbel temperature during training.'} )





def 	SCREAMING_SNAKE_CASE__    (      __lowerCAmelCase    ,		__lowerCAmelCase							):
    logging.basicConfig(
        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"    ,		datefmt="%m/%d/%Y %H:%M:%S"    ,		handlers=[logging.StreamHandler(sys.stdout							)]    ,		)
    snake_case__						=				logging.WARNING
    if model_args.verbose_logging:
        snake_case__						=				logging.DEBUG
    elif trainer_utils.is_main_process(training_args.local_rank							):
        snake_case__						=				logging.INFO
    logger.setLevel(__lowerCAmelCase							)




@dataclass
class 					_SCREAMING_SNAKE_CASE  :
      _A						:		str    	=     field(
          default=__UpperCamelCase       ,					metadata={'help': 'The name of the dataset to use (via the datasets library).'} )
      _A						:		Optional[str]    	=     field(
          default=__UpperCamelCase       ,					metadata={'help': 'The configuration name of the dataset to use (via the datasets library).'} )
      _A						:		Optional[str]    	=     field(
          default='train'       ,					metadata={
              'help': 'The name of the training data set split to use (via the datasets library). Defaults to \'train\''
          }       ,					)
      _A						:		Optional[str]    	=     field(
          default='validation'       ,					metadata={
              'help': (
                  'The name of the validation data set split to use (via the datasets library). Defaults to \'validation\''
              )
          }       ,					)
      _A						:		Optional[str]    	=     field(
          default='file'       ,					metadata={'help': 'Column in the dataset that contains speech file path. Defaults to \'file\''}       ,					)
      _A						:		bool    	=     field(
          default=__UpperCamelCase       ,					metadata={'help': 'Overwrite the cached preprocessed datasets or not.'} )
      _A						:		Optional[int]    	=     field(
          default=1       ,					metadata={
              'help': 'The percentage of the train set used as validation set in case there\'s no validation split'
          }       ,					)
      _A						:		Optional[int]    	=     field(
          default=__UpperCamelCase       ,					metadata={'help': 'The number of processes to use for the preprocessing.'}       ,					)
      _A						:		Optional[float]    	=     field(
          default=2_0.0       ,					metadata={'help': 'Filter audio files that are longer than `max_duration_in_seconds` seconds'} )





@dataclass
class 					_SCREAMING_SNAKE_CASE  :
      _A						:		WavaVecaForPreTraining
      _A						:		WavaVecaFeatureExtractor
      _A						:		Union[bool, str]    	=     "longest"
      _A						:		Optional[int]    	=     None
      _A						:		Optional[int]    	=     None
      def __call__(			self		,	lowerCamelCase ):
          # reformat list to dict and set to pytorch format
          snake_case__						=				self.feature_extractor.pad(
              lowerCamelCase		,	max_length=self.max_length		,	padding=self.padding		,	pad_to_multiple_of=self.pad_to_multiple_of		,	return_tensors="pt"		,	)
          snake_case__						=				self.model._get_feat_extract_output_lengths(batch["input_values"].shape[-1] )

          snake_case__						=				batch["input_values"].shape[0]

          # make sure that no loss is computed on padded inputs
          if batch["attention_mask"] is not None:
              # compute real output lengths according to convolution formula
              snake_case__						=				self.model._get_feat_extract_output_lengths(batch["attention_mask"].sum(-1 ) ).to(
                  torch.long )

              snake_case__						=				torch.zeros(
                  (batch_size, mask_indices_seq_length)		,	dtype=torch.long		,	device=batch["input_values"].device )

              # these two operations makes sure that all values
              # before the output lengths indices are attended to
              snake_case__						=				1
              snake_case__						=				attention_mask.flip([-1] ).cumsum(-1 ).flip([-1] ).bool()

          # sample randomly masked indices
          snake_case__						=				_compute_mask_indices(
              (batch_size, mask_indices_seq_length)		,	self.model.config.mask_time_prob		,	self.model.config.mask_time_length		,	attention_mask=lowerCamelCase		,	min_masks=2		,	)

          return batch





class 					_SCREAMING_SNAKE_CASE  (      __UpperCamelCase ):
      def __init__(			self		,	*lowerCamelCase		,	lowerCamelCase=1		,	lowerCamelCase=0		,	lowerCamelCase=1.0		,	**lowerCamelCase ):
          super().__init__(*lowerCamelCase		,	**lowerCamelCase )
          snake_case__						=				0
          snake_case__						=				max_gumbel_temp
          snake_case__						=				min_gumbel_temp
          snake_case__						=				gumbel_temp_decay



      def A_			(			self		,	lowerCamelCase		,	lowerCamelCase ):
          model.train()
          snake_case__						=				self._prepare_inputs(lowerCamelCase )

          if self.use_amp:
              with autocast():
                  snake_case__						=				self.compute_loss(lowerCamelCase		,	lowerCamelCase )
          else:
              snake_case__						=				self.compute_loss(lowerCamelCase		,	lowerCamelCase )

          if self.args.n_gpu > 1 or self.deepspeed:
              if model.module.config.ctc_loss_reduction == "mean":
                  snake_case__						=				loss.mean()
              elif model.module.config.ctc_loss_reduction == "sum":
                  snake_case__						=				loss.sum() / (inputs["mask_time_indices"]).sum()
              else:
                  raise ValueError(F"""{model.config.ctc_loss_reduction} is not valid. Choose one of ['mean', 'sum']""" )

          if self.args.gradient_accumulation_steps > 1:
              snake_case__						=				loss / self.args.gradient_accumulation_steps

          if self.use_amp:
              self.scaler.scale(lowerCamelCase ).backward()
          elif self.use_apex:
              with amp.scale_loss(lowerCamelCase		,	self.optimizer ) as scaled_loss:
                  scaled_loss.backward()
          elif self.deepspeed:
              self.deepspeed.backward(lowerCamelCase )
          else:
              loss.backward()

          self.num_update_step += 1
          # make sure gumbel softmax temperature is decayed
          if self.args.n_gpu > 1 or self.deepspeed:
              model.module.set_gumbel_temperature(
                  max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step		,	self.min_gumbel_temp ) )
          else:
              model.set_gumbel_temperature(
                  max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step		,	self.min_gumbel_temp ) )

          return loss.detach()





def 	SCREAMING_SNAKE_CASE__    (      ):
    # See all possible arguments in src/transformers/training_args.py
    # or by passing the --help flag to this script.
    # We now keep distinct sets of args, for a cleaner separation of concerns.

    snake_case__						=				HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)							)

    snake_case__						,					snake_case__						,					snake_case__						=				parser.parse_args_into_dataclasses()
    configure_logger(__lowerCAmelCase    ,		__lowerCAmelCase							)

    # Downloading and loading a dataset from the hub.
    snake_case__						=				load_dataset(data_args.dataset_name    ,		data_args.dataset_config_name    ,		cache_dir=model_args.cache_dir							)

    if "validation" not in datasets.keys():
        # make sure only "validation" and "train" keys remain"
        snake_case__						=				DatasetDict()
        snake_case__						=				load_dataset(
            data_args.dataset_name    ,		data_args.dataset_config_name    ,		split=F"""{data_args.train_split_name}[:{data_args.validation_split_percentage}%]"""    ,		cache_dir=model_args.cache_dir    ,		)
        snake_case__						=				load_dataset(
            data_args.dataset_name    ,		data_args.dataset_config_name    ,		split=F"""{data_args.train_split_name}[{data_args.validation_split_percentage}%:]"""    ,		cache_dir=model_args.cache_dir    ,		)
    else:
        # make sure only "validation" and "train" keys remain"
        snake_case__						=				DatasetDict()
        snake_case__						=				load_dataset(
            data_args.dataset_name    ,		data_args.dataset_config_name    ,		split="validation"    ,		cache_dir=model_args.cache_dir    ,		)
        snake_case__						=				load_dataset(
            data_args.dataset_name    ,		data_args.dataset_config_name    ,		split=F"""{data_args.train_split_name}"""    ,		cache_dir=model_args.cache_dir    ,		)

    # only normalized-inputs-training is supported
    snake_case__						=				WavaVecaFeatureExtractor.from_pretrained(
        model_args.model_name_or_path    ,		cache_dir=model_args.cache_dir    ,		do_normalize=__lowerCAmelCase							)

    def prepare_dataset(__lowerCAmelCase							):
        # check that all files have the correct sampling rate
        snake_case__						,					snake_case__						=				librosa.load(batch[data_args.speech_file_column]    ,		sr=feature_extractor.sampling_rate							)
        return batch

    # load audio files into numpy arrays
    snake_case__						=				datasets.map(
        __lowerCAmelCase    ,		num_proc=data_args.preprocessing_num_workers    ,		remove_columns=datasets["train"].column_names							)

    # filter audio files that are too long
    snake_case__						=				vectorized_datasets.filter(
        lambda __lowerCAmelCase							: len(data["speech"]							) < int(data_args.max_duration_in_seconds * feature_extractor.sampling_rate							)							)

    def normalize(__lowerCAmelCase							):
        return feature_extractor(batch["speech"]    ,		sampling_rate=feature_extractor.sampling_rate							)

    # normalize and transform to `BatchFeatures`
    snake_case__						=				vectorized_datasets.map(
        __lowerCAmelCase    ,		batched=__lowerCAmelCase    ,		num_proc=data_args.preprocessing_num_workers    ,		load_from_cache_file=not data_args.overwrite_cache    ,		remove_columns=vectorized_datasets["train"].column_names    ,		)

    # pretraining is only supported for "newer" stable layer norm architecture
    # apply_spec_augment has to be True, mask_feature_prob has to be 0.0
    snake_case__						=				WavaVecaConfig.from_pretrained(
        model_args.model_name_or_path    ,		cache_dir=model_args.cache_dir    ,		gradient_checkpointing=training_args.gradient_checkpointing    ,		)

    if not config.do_stable_layer_norm or config.feat_extract_norm != "layer":
        raise ValueError(
            "PreTraining is only supported for ``config.do_stable_layer_norm=True`` and"
            " ``config.feat_extract_norm='layer'"							)

    snake_case__						=				WavaVecaForPreTraining(__lowerCAmelCase							)

    snake_case__						=				DataCollatorForWavaVecaPretraining(model=__lowerCAmelCase    ,		feature_extractor=__lowerCAmelCase							)

    snake_case__						=				WavaVecaPreTrainer(
        model=__lowerCAmelCase    ,		data_collator=__lowerCAmelCase    ,		args=__lowerCAmelCase    ,		train_dataset=vectorized_datasets["train"]    ,		eval_dataset=vectorized_datasets["validation"]    ,		tokenizer=__lowerCAmelCase    ,		max_gumbel_temp=model_args.max_gumbel_temperature    ,		min_gumbel_temp=model_args.min_gumbel_temperature    ,		gumbel_temp_decay=model_args.gumbel_temperature_decay    ,		)
    trainer.train()


if __name__ == "__main__":
     main()





import unittest

from transformers import SPIECE_UNDERLINE, ReformerTokenizer, ReformerTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


__magic_name__            =  get_tests_dir('''fixtures/test_sentencepiece.model''')




@require_sentencepiece
@require_tokenizers
class 					_SCREAMING_SNAKE_CASE  (      __UpperCamelCase       ,					unittest.TestCase ):
      _A						:		Optional[Any]    	=     ReformerTokenizer
      _A						:		str    	=     ReformerTokenizerFast
      _A						:		List[str]    	=     True
      _A						:		Tuple    	=     False
      _A						:		str    	=     True
      def A_			(			self ):
          super().setUp()

          snake_case__						=				ReformerTokenizer(lowerCamelCase		,	keep_accents=lowerCamelCase )
          tokenizer.save_pretrained(self.tmpdirname )
      def A_			(			self ):
          snake_case__						=				"<s>"
          snake_case__						=				1

          self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase )		,	lowerCamelCase )
          self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase )		,	lowerCamelCase )
      def A_			(			self ):
          snake_case__						=				list(self.get_tokenizer().get_vocab().keys() )

          self.assertEqual(vocab_keys[0]		,	"<unk>" )
          self.assertEqual(vocab_keys[1]		,	"<s>" )
          self.assertEqual(vocab_keys[-1]		,	"j" )
          self.assertEqual(len(lowerCamelCase )		,	10_00 )
      def A_			(			self ):
          self.assertEqual(self.get_tokenizer().vocab_size		,	10_00 )
      def A_			(			self ):
          if not self.test_rust_tokenizer:
              return

          snake_case__						=				self.get_tokenizer()
          snake_case__						=				self.get_rust_tokenizer()

          snake_case__						=				"I was born in 92000, and this is falsé."

          snake_case__						=				tokenizer.tokenize(lowerCamelCase )
          snake_case__						=				rust_tokenizer.tokenize(lowerCamelCase )
          self.assertListEqual(lowerCamelCase		,	lowerCamelCase )

          snake_case__						=				tokenizer.encode(lowerCamelCase		,	add_special_tokens=lowerCamelCase )
          snake_case__						=				rust_tokenizer.encode(lowerCamelCase		,	add_special_tokens=lowerCamelCase )
          self.assertListEqual(lowerCamelCase		,	lowerCamelCase )

          snake_case__						=				self.get_rust_tokenizer()
          snake_case__						=				tokenizer.encode(lowerCamelCase )
          snake_case__						=				rust_tokenizer.encode(lowerCamelCase )
          self.assertListEqual(lowerCamelCase		,	lowerCamelCase )
      def A_			(			self		,	lowerCamelCase=15 ):
          for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
              with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})""" ):
                  snake_case__						=				self.rust_tokenizer_class.from_pretrained(lowerCamelCase		,	**lowerCamelCase )

                  # Simple input
                  snake_case__						=				"This is a simple input"
                  snake_case__						=				["This is a simple input 1", "This is a simple input 2"]
                  snake_case__						=				("This is a simple input", "This is a pair")
                  snake_case__						=				[
                      ("This is a simple input 1", "This is a simple input 2"),
                      ("This is a simple pair 1", "This is a simple pair 2"),
                  ]

                  # Simple input tests
                  self.assertRaises(lowerCamelCase		,	tokenizer_r.encode		,	lowerCamelCase		,	max_length=lowerCamelCase		,	padding="max_length" )

                  # Simple input
                  self.assertRaises(lowerCamelCase		,	tokenizer_r.encode_plus		,	lowerCamelCase		,	max_length=lowerCamelCase		,	padding="max_length" )

                  # Simple input
                  self.assertRaises(
                      lowerCamelCase		,	tokenizer_r.batch_encode_plus		,	lowerCamelCase		,	max_length=lowerCamelCase		,	padding="max_length"		,	)

                  # Pair input
                  self.assertRaises(lowerCamelCase		,	tokenizer_r.encode		,	lowerCamelCase		,	max_length=lowerCamelCase		,	padding="max_length" )

                  # Pair input
                  self.assertRaises(lowerCamelCase		,	tokenizer_r.encode_plus		,	lowerCamelCase		,	max_length=lowerCamelCase		,	padding="max_length" )

                  # Pair input
                  self.assertRaises(
                      lowerCamelCase		,	tokenizer_r.batch_encode_plus		,	lowerCamelCase		,	max_length=lowerCamelCase		,	padding="max_length"		,	)
      def A_			(			self ):
          pass
      def A_			(			self ):
          snake_case__						=				ReformerTokenizer(lowerCamelCase		,	keep_accents=lowerCamelCase )

          snake_case__						=				tokenizer.tokenize("This is a test" )
          self.assertListEqual(lowerCamelCase		,	["▁This", "▁is", "▁a", "▁t", "est"] )

          self.assertListEqual(
              tokenizer.convert_tokens_to_ids(lowerCamelCase )		,	[2_85, 46, 10, 1_70, 3_82]		,	)

          snake_case__						=				tokenizer.tokenize("I was born in 92000, and this is falsé." )
          self.assertListEqual(
              lowerCamelCase		,	[
                  SPIECE_UNDERLINE + "I",
                  SPIECE_UNDERLINE + "was",
                  SPIECE_UNDERLINE + "b",
                  "or",
                  "n",
                  SPIECE_UNDERLINE + "in",
                  SPIECE_UNDERLINE + "",
                  "9",
                  "2",
                  "0",
                  "0",
                  "0",
                  ",",
                  SPIECE_UNDERLINE + "and",
                  SPIECE_UNDERLINE + "this",
                  SPIECE_UNDERLINE + "is",
                  SPIECE_UNDERLINE + "f",
                  "al",
                  "s",
                  "é",
                  ".",
              ]		,	)
          snake_case__						=				tokenizer.convert_tokens_to_ids(lowerCamelCase )
          self.assertListEqual(
              lowerCamelCase		,	[8, 21, 84, 55, 24, 19, 7, 0, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 0, 4]		,	)

          snake_case__						=				tokenizer.convert_ids_to_tokens(lowerCamelCase )
          self.assertListEqual(
              lowerCamelCase		,	[
                  SPIECE_UNDERLINE + "I",
                  SPIECE_UNDERLINE + "was",
                  SPIECE_UNDERLINE + "b",
                  "or",
                  "n",
                  SPIECE_UNDERLINE + "in",
                  SPIECE_UNDERLINE + "",
                  "<unk>",
                  "2",
                  "0",
                  "0",
                  "0",
                  ",",
                  SPIECE_UNDERLINE + "and",
                  SPIECE_UNDERLINE + "this",
                  SPIECE_UNDERLINE + "is",
                  SPIECE_UNDERLINE + "f",
                  "al",
                  "s",
                  "<unk>",
                  ".",
              ]		,	)
      @cached_property
      def A_			(			self ):
          return ReformerTokenizer.from_pretrained("google/reformer-crime-and-punishment" )
      @slow
      def A_			(			self ):
          snake_case__						=				"Hello World!"
          snake_case__						=				[1_26, 32, 2_62, 1_52, 38, 72, 2_87]

          self.assertListEqual(lowerCamelCase		,	self.big_tokenizer.encode(lowerCamelCase ) )
      @slow
      def A_			(			self ):
          snake_case__						=				(
              "This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) \" [ ] ! : - . Also we will"
              " add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth"
          )
          snake_case__						=				[
              1_08,
              2_65,
              24,
              1_11,
              4,
              2_58,
              1_56,
              35,
              28,
              2_75,
              3,
              2_59,
              2_97,
              2_60,
              84,
              4,
              35,
              1_10,
              44,
              8,
              2_59,
              91,
              2_68,
              21,
              11,
              2_09,
              2_74,
              1_09,
              2_66,
              2_77,
              1_17,
              86,
              93,
              3_15,
              2_58,
              2_78,
              2_58,
              2_77,
              2_58,
              0,
              2_58,
              2_88,
              2_58,
              3_19,
              2_58,
              0,
              2_58,
              0,
              2_58,
              0,
              2_58,
              0,
              2_58,
              2_87,
              2_58,
              3_15,
              2_58,
              2_89,
              2_58,
              2_78,
              99,
              2_69,
              2_66,
              2_62,
              8,
              2_59,
              2_41,
              4,
              2_17,
              2_30,
              2_68,
              2_66,
              55,
              1_68,
              1_06,
              75,
              1_93,
              2_66,
              2_23,
              27,
              49,
              26,
              2_82,
              25,
              2_64,
              2_99,
              19,
              26,
              0,
              2_58,
              2_77,
              1_17,
              86,
              93,
              1_76,
              1_83,
              2_70,
              11,
              2_62,
              42,
              61,
              2_65,
          ]

          self.assertListEqual(lowerCamelCase		,	self.big_tokenizer.encode(lowerCamelCase ) )
      @require_torch
      @slow
      def A_			(			self ):
          import torch

          from transformers import ReformerConfig, ReformerModel

          # Build sequence
          snake_case__						=				list(self.big_tokenizer.get_vocab().keys() )[:10]
          snake_case__						=				" ".join(lowerCamelCase )
          snake_case__						=				self.big_tokenizer.encode_plus(lowerCamelCase		,	return_tensors="pt" )
          snake_case__						=				self.big_tokenizer.batch_encode_plus([sequence, sequence]		,	return_tensors="pt" )

          snake_case__						=				ReformerConfig()
          # The input gets padded during training so adjust the axial position encodings from the pretrained model value of (512, 1024)
          snake_case__						=				encoded_sequence["input_ids"].shape
          snake_case__						=				ReformerModel(lowerCamelCase )

          # Reformer has config.vocab_size == tokenizer.vocab_size == len(tokenizer) - 1 = 320; len(tokenizer) is 321 (including a pad token with id 320)
          assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

          with torch.no_grad():
              model(**lowerCamelCase )
              model(**lowerCamelCase )



      @slow
      def A_			(			self ):
          # fmt: off
          snake_case__						=				{"input_ids": [[1_08, 2_65, 24, 1_11, 4, 2_58, 1_56, 7, 51, 2_79, 58, 7, 76, 25, 69, 2_78], [1_40, 2_43, 2_64, 1_34, 17, 2_67, 77, 2_63, 22, 2_62, 2_97, 2_58, 3_04, 1_77, 2_79, 2_66, 14, 89, 13, 35, 2_61, 2_99, 2_72, 1_37, 2_75, 2_78]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
          # fmt: on

          # This tokenizer does not know some characters like ")".
          # That is the reason why we use very simple texts here.
          # Also see https://github.com/huggingface/transformers/pull/11737#issuecomment-850769064
          snake_case__						=				[
              "This is a very simple sentence.",
              "The quick brown fox jumps over the lazy dog.",
          ]

          self.tokenizer_integration_test_util(
              expected_encoding=lowerCamelCase		,	model_name="google/reformer-crime-and-punishment"		,	revision="0e6c3decb8211d49bf881013425dc8b0448b3f5a"		,	padding=lowerCamelCase		,	sequences=lowerCamelCase		,	)



