




import argparse
import struct
import unittest
class        __snake_case  :



				def __init__(      self      :		List[str]		,	_UpperCAmelCase      :		bytes      )  ->    List[Any]:





								'''simple docstring'''




								_lowerCAmelCase    :    Optional[Any]										=      data

								# Initialize hash values
								_lowerCAmelCase    :    List[str]										=      [
								    0X6A_09_E6_67,
								    0XBB_67_AE_85,
								    0X3C_6E_F3_72,
								    0XA5_4F_F5_3A,
								    0X51_0E_52_7F,
								    0X9B_05_68_8C,
								    0X1F_83_D9_AB,
								    0X5B_E0_CD_19,
								]

								# Initialize round constants
								_lowerCAmelCase    :    Tuple										=      [
								    0X42_8A_2F_98,
								    0X71_37_44_91,
								    0XB5_C0_FB_CF,
								    0XE9_B5_DB_A5,
								    0X39_56_C2_5B,
								    0X59_F1_11_F1,
								    0X92_3F_82_A4,
								    0XAB_1C_5E_D5,
								    0XD8_07_AA_98,
								    0X12_83_5B_01,
								    0X24_31_85_BE,
								    0X55_0C_7D_C3,
								    0X72_BE_5D_74,
								    0X80_DE_B1_FE,
								    0X9B_DC_06_A7,
								    0XC1_9B_F1_74,
								    0XE4_9B_69_C1,
								    0XEF_BE_47_86,
								    0X0F_C1_9D_C6,
								    0X24_0C_A1_CC,
								    0X2D_E9_2C_6F,
								    0X4A_74_84_AA,
								    0X5C_B0_A9_DC,
								    0X76_F9_88_DA,
								    0X98_3E_51_52,
								    0XA8_31_C6_6D,
								    0XB0_03_27_C8,
								    0XBF_59_7F_C7,
								    0XC6_E0_0B_F3,
								    0XD5_A7_91_47,
								    0X06_CA_63_51,
								    0X14_29_29_67,
								    0X27_B7_0A_85,
								    0X2E_1B_21_38,
								    0X4D_2C_6D_FC,
								    0X53_38_0D_13,
								    0X65_0A_73_54,
								    0X76_6A_0A_BB,
								    0X81_C2_C9_2E,
								    0X92_72_2C_85,
								    0XA2_BF_E8_A1,
								    0XA8_1A_66_4B,
								    0XC2_4B_8B_70,
								    0XC7_6C_51_A3,
								    0XD1_92_E8_19,
								    0XD6_99_06_24,
								    0XF4_0E_35_85,
								    0X10_6A_A0_70,
								    0X19_A4_C1_16,
								    0X1E_37_6C_08,
								    0X27_48_77_4C,
								    0X34_B0_BC_B5,
								    0X39_1C_0C_B3,
								    0X4E_D8_AA_4A,
								    0X5B_9C_CA_4F,
								    0X68_2E_6F_F3,
								    0X74_8F_82_EE,
								    0X78_A5_63_6F,
								    0X84_C8_78_14,
								    0X8C_C7_02_08,
								    0X90_BE_FF_FA,
								    0XA4_50_6C_EB,
								    0XBE_F9_A3_F7,
								    0XC6_71_78_F2,
								]

								_lowerCAmelCase    :    str										=      self.preprocessing(self.data      )
								self.final_hash()



				@staticmethod
				def       SCREAMING_SNAKE_CASE       (      _UpperCAmelCase      :		bytes      )  ->    Optional[int]:





								'''simple docstring'''




								_lowerCAmelCase    :    List[str]										=      B"""\x80""" + (B"""\x00""" * (63 - (len(_snake_case      ) + 8) % 64))
								_lowerCAmelCase    :    str										=      struct.pack(""">Q"""		,	(len(_snake_case      ) * 8)      )
								return data + padding + big_endian_integer



				def       SCREAMING_SNAKE_CASE       (      self      :		Optional[int]      )  ->    Union[str, Any]:





								'''simple docstring'''




								_lowerCAmelCase    :    Tuple										=      [
								    self.preprocessed_data[x : x + 64]
								    for x in range(0		,	len(self.preprocessed_data      )		,	64      )
								]

								for block in self.blocks:
												# Convert the given block into a list of 4 byte integers
												_lowerCAmelCase    :    List[Any]										=      list(struct.unpack(""">16L"""		,	_snake_case      )      )
												# add 48 0-ed integers
												words += [0] * 48

												_lowerCAmelCase					,    _lowerCAmelCase					,    _lowerCAmelCase					,    _lowerCAmelCase					,    _lowerCAmelCase					,    _lowerCAmelCase					,    _lowerCAmelCase					,    _lowerCAmelCase    :    str										=      self.hashes

												for index in range(0		,	64      ):
																if index > 15:
																				# modify the zero-ed indexes at the end of the array
																				_lowerCAmelCase    :    Union[str, Any]										=      (
																				    self.ror(words[index - 15]		,	7      )
																				    ^ self.ror(words[index - 15]		,	18      )
																				    ^ (words[index - 15] >> 3)
																				)
																				_lowerCAmelCase    :    int										=      (
																				    self.ror(words[index - 2]		,	17      )
																				    ^ self.ror(words[index - 2]		,	19      )
																				    ^ (words[index - 2] >> 10)
																				)

																				_lowerCAmelCase    :    Tuple										=      (
																				    words[index - 16] + sa + words[index - 7] + sa
																				) % 0X1_00_00_00_00

																# Compression
																_lowerCAmelCase    :    Any										=      self.ror(_snake_case		,	6      ) ^ self.ror(_snake_case		,	11      ) ^ self.ror(_snake_case		,	25      )
																_lowerCAmelCase    :    Any										=      (e & f) ^ ((~e & 0XFF_FF_FF_FF) & g)
																_lowerCAmelCase    :    Any										=      (
																    h + sa + ch + self.round_constants[index] + words[index]
																) % 0X1_00_00_00_00
																_lowerCAmelCase    :    Optional[Any]										=      self.ror(_snake_case		,	2      ) ^ self.ror(_snake_case		,	13      ) ^ self.ror(_snake_case		,	22      )
																_lowerCAmelCase    :    Optional[int]										=      (a & b) ^ (a & c) ^ (b & c)
																_lowerCAmelCase    :    Union[str, Any]										=      (sa + maj) % 0X1_00_00_00_00

																_lowerCAmelCase					,    _lowerCAmelCase					,    _lowerCAmelCase					,    _lowerCAmelCase					,    _lowerCAmelCase					,    _lowerCAmelCase					,    _lowerCAmelCase					,    _lowerCAmelCase    :    Optional[Any]										=      (
																    g,
																    f,
																    e,
																    ((d + tempa) % 0X1_00_00_00_00),
																    c,
																    b,
																    a,
																    ((tempa + tempa) % 0X1_00_00_00_00),
																)

												_lowerCAmelCase    :    Union[str, Any]										=      [a, b, c, d, e, f, g, h]

												# Modify final values
												_lowerCAmelCase    :    str										=      [
												    ((element + mutated_hash_values[index]) % 0X1_00_00_00_00)
												    for index, element in enumerate(self.hashes      )
												]

								_lowerCAmelCase    :    int										=      """""".join([hex(_snake_case      )[2:].zfill(8      ) for value in self.hashes]      )



				def       SCREAMING_SNAKE_CASE       (      self      :		Dict		,	_UpperCAmelCase      :		int		,	_UpperCAmelCase      :		int      )  ->    Tuple:





								'''simple docstring'''




								return 0XFF_FF_FF_FF & (value << (32 - rotations)) | (value >> rotations)






class        __snake_case  (unittest.TestCase		):



				def       SCREAMING_SNAKE_CASE       (      self      :		str      )  ->    Tuple:





								'''simple docstring'''




								import hashlib

								_lowerCAmelCase    :    str										=      bytes("""Test String"""		,	"""utf-8"""      )
								self.assertEqual(SHAaaa(_snake_case      ).hash		,	hashlib.shaaaa(_snake_case      ).hexdigest()      )






def 							_UpperCAmelCase  ():
				'''simple docstring'''
				import doctest

				doctest.testmod()

				_lowerCAmelCase    :    List[str]										=      argparse.ArgumentParser()
				parser.add_argument(
				    """-s"""      ,    """--string"""      ,    dest="""input_string"""      ,    default="""Hello World!! Welcome to Cryptography"""      ,    help="""Hash the string"""      ,    )
				parser.add_argument(
				    """-f"""      ,    """--file"""      ,    dest="""input_file"""      ,    help="""Hash contents of a file"""       )

				_lowerCAmelCase    :    Dict										=      parser.parse_args()

				_lowerCAmelCase    :    List[str]										=      args.input_string

				# hash input should be a bytestring
				if args.input_file:
								with open(args.input_file      ,    """rb"""       ) as f:
												_lowerCAmelCase    :    str										=      f.read()
				else:
								_lowerCAmelCase    :    Optional[Any]										=      bytes(__UpperCamelCase      ,    """utf-8"""       )

				print(SHAaaa(__UpperCamelCase       ).hash       )


if __name__ == "__main__":
		main()







import os
from pathlib import Path

import numpy as np
import pytest
from pack_dataset import pack_data_dir
from parameterized import parameterized
from save_len_file import save_len_file
from torch.utils.data import DataLoader

from transformers import AutoTokenizer
from transformers.models.mbart.modeling_mbart import shift_tokens_right
from transformers.testing_utils import TestCasePlus, slow
from utils import FAIRSEQ_AVAILABLE, DistributedSortishSampler, LegacySeqaSeqDataset, SeqaSeqDataset


_lowerCamelCase      :  int      						=						"bert-base-cased"
_lowerCamelCase      :  Union[str, Any]      						=						"google/pegasus-xsum"
_lowerCamelCase      :  Optional[int]      						=						[" Sam ate lunch today.", "Sams lunch ingredients."]
_lowerCamelCase      :  Dict      						=						["A very interesting story about what I ate for lunch.", "Avocado, celery, turkey, coffee"]
_lowerCamelCase      :  Any      						=						"patrickvonplaten/t5-tiny-random"
_lowerCamelCase      :  Dict      						=						"sshleifer/bart-tiny-random"
_lowerCamelCase      :  int      						=						"sshleifer/tiny-mbart"
_lowerCamelCase      :  List[Any]      						=						"sshleifer/tiny-marian-en-de"




def 							_UpperCAmelCase  (UpperCamelCase_ : Path      ,    UpperCamelCase_ : list       ):
				'''simple docstring'''
				_lowerCAmelCase    :    Union[str, Any]										=      """\n""".join(UpperCamelCase_       )
				Path(UpperCamelCase_       ).open("""w"""       ).writelines(UpperCamelCase_       )




def 							_UpperCAmelCase  (UpperCamelCase_ : str       ):
				'''simple docstring'''
				for split in ["train", "val", "test"]:
								_dump_articles(os.path.join(UpperCamelCase_      ,    F"{split}.source"       )      ,    UpperCamelCase_       )
								_dump_articles(os.path.join(UpperCamelCase_      ,    F"{split}.target"       )      ,    UpperCamelCase_       )
				return tmp_dir





class        __snake_case  (_a		):



				@parameterized.expand(
				    [
				        MBART_TINY,
				        MARIAN_TINY,
				        T5_TINY,
				        BART_TINY,
				        PEGASUS_XSUM,
				    ]		,	)
				@slow
				def       SCREAMING_SNAKE_CASE       (      self      :		Tuple		,	_UpperCAmelCase      :		List[str]      )  ->    int:





								'''simple docstring'''




								_lowerCAmelCase    :    Union[str, Any]										=      AutoTokenizer.from_pretrained(_UpperCAmelCase      )
								_lowerCAmelCase    :    Optional[Any]										=      make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()      )
								_lowerCAmelCase    :    Any										=      max(len(tokenizer.encode(_UpperCAmelCase      )      ) for a in ARTICLES      )
								_lowerCAmelCase    :    Dict										=      max(len(tokenizer.encode(_UpperCAmelCase      )      ) for a in SUMMARIES      )
								_lowerCAmelCase    :    List[str]										=      4
								_lowerCAmelCase    :    List[Any]										=      8
								assert max_len_target > max_src_len  # Will be truncated
								assert max_len_source > max_src_len  # Will be truncated
								_lowerCAmelCase					,    _lowerCAmelCase    :    Any										=      """ro_RO""", """de_DE"""  # ignored for all but mbart, but never causes error.
								_lowerCAmelCase    :    Tuple										=      SeqaSeqDataset(
								    _UpperCAmelCase		,	data_dir=_UpperCAmelCase		,	type_path="""train"""		,	max_source_length=_UpperCAmelCase		,	max_target_length=_UpperCAmelCase		,	src_lang=_UpperCAmelCase		,	tgt_lang=_UpperCAmelCase		,	)
								_lowerCAmelCase    :    int										=      DataLoader(_UpperCAmelCase		,	batch_size=2		,	collate_fn=train_dataset.collate_fn      )
								for batch in dataloader:
												assert isinstance(_UpperCAmelCase		,	_UpperCAmelCase      )
												assert batch["attention_mask"].shape == batch["input_ids"].shape
												# show that articles were trimmed.
												assert batch["input_ids"].shape[1] == max_src_len
												# show that targets are the same len
												assert batch["labels"].shape[1] == max_tgt_len
												if tok_name != MBART_TINY:
																continue
												# check language codes in correct place
												_lowerCAmelCase    :    Dict										=      shift_tokens_right(batch["""labels"""]		,	tokenizer.pad_token_id      )
												assert batch["decoder_input_ids"][0, 0].item() == tokenizer.lang_code_to_id[tgt_lang]
												assert batch["decoder_input_ids"][0, -1].item() == tokenizer.eos_token_id
												assert batch["input_ids"][0, -2].item() == tokenizer.eos_token_id
												assert batch["input_ids"][0, -1].item() == tokenizer.lang_code_to_id[src_lang]

												break  # No need to test every batch



				@parameterized.expand([BART_TINY, BERT_BASE_CASED]      )
				def       SCREAMING_SNAKE_CASE       (      self      :		Tuple		,	_UpperCAmelCase      :		List[str]      )  ->    Dict:





								'''simple docstring'''




								_lowerCAmelCase    :    Dict										=      AutoTokenizer.from_pretrained(_UpperCAmelCase      )
								_lowerCAmelCase    :    str										=      make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()      )
								_lowerCAmelCase    :    Optional[int]										=      max(len(tokenizer.encode(_UpperCAmelCase      )      ) for a in ARTICLES      )
								_lowerCAmelCase    :    str										=      max(len(tokenizer.encode(_UpperCAmelCase      )      ) for a in SUMMARIES      )
								_lowerCAmelCase    :    Union[str, Any]										=      4
								_lowerCAmelCase    :    Dict										=      LegacySeqaSeqDataset(
								    _UpperCAmelCase		,	data_dir=_UpperCAmelCase		,	type_path="""train"""		,	max_source_length=20		,	max_target_length=_UpperCAmelCase		,	)
								_lowerCAmelCase    :    str										=      DataLoader(_UpperCAmelCase		,	batch_size=2		,	collate_fn=train_dataset.collate_fn      )
								for batch in dataloader:
												assert batch["attention_mask"].shape == batch["input_ids"].shape
												# show that articles were trimmed.
												assert batch["input_ids"].shape[1] == max_len_source
												assert 20 >= batch["input_ids"].shape[1]  # trimmed significantly
												# show that targets were truncated
												assert batch["labels"].shape[1] == trunc_target  # Truncated
												assert max_len_target > trunc_target  # Truncated
												break  # No need to test every batch



				def       SCREAMING_SNAKE_CASE       (      self      :		Optional[int]      )  ->    str:





								'''simple docstring'''




								_lowerCAmelCase    :    int										=      AutoTokenizer.from_pretrained("""facebook/mbart-large-cc25"""      )

								_lowerCAmelCase    :    List[str]										=      Path(make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()      )      )
								_lowerCAmelCase    :    List[Any]										=      tmp_dir.joinpath("""train.source"""      ).open().readlines()
								_lowerCAmelCase    :    Tuple										=      Path(make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()      )      )
								pack_data_dir(_UpperCAmelCase		,	_UpperCAmelCase		,	128		,	_UpperCAmelCase      )
								_lowerCAmelCase    :    List[str]										=      {x.name for x in tmp_dir.iterdir()}
								_lowerCAmelCase    :    List[Any]										=      {x.name for x in save_dir.iterdir()}
								_lowerCAmelCase    :    Optional[Any]										=      save_dir.joinpath("""train.source"""      ).open().readlines()
								# orig: [' Sam ate lunch today.\n', 'Sams lunch ingredients.']
								# desired_packed: [' Sam ate lunch today.\n Sams lunch ingredients.']
								assert len(_UpperCAmelCase      ) < len(_UpperCAmelCase      )
								assert len(_UpperCAmelCase      ) == 1
								assert len(packed_examples[0]      ) == sum(len(_UpperCAmelCase      ) for x in orig_examples      )
								assert orig_paths == new_paths



				@pytest.mark.skipif(not FAIRSEQ_AVAILABLE		,	reason="""This test requires fairseq"""      )
				def       SCREAMING_SNAKE_CASE       (      self      :		Any      )  ->    str:





								'''simple docstring'''




								if not FAIRSEQ_AVAILABLE:
												return
								_lowerCAmelCase					,    _lowerCAmelCase					,    _lowerCAmelCase    :    int										=      self._get_dataset(max_len=64      )
								_lowerCAmelCase    :    Optional[Any]										=      64
								_lowerCAmelCase    :    Union[str, Any]										=      ds.make_dynamic_sampler(_UpperCAmelCase		,	required_batch_size_multiple=_UpperCAmelCase      )
								_lowerCAmelCase    :    Tuple										=      [len(_UpperCAmelCase      ) for x in batch_sampler]
								assert len(set(_UpperCAmelCase      )      ) > 1  # it's not dynamic batch size if every batch is the same length
								assert sum(_UpperCAmelCase      ) == len(_UpperCAmelCase      )  # no dropped or added examples
								_lowerCAmelCase    :    List[Any]										=      DataLoader(_UpperCAmelCase		,	batch_sampler=_UpperCAmelCase		,	collate_fn=ds.collate_fn		,	num_workers=2      )
								_lowerCAmelCase    :    List[Any]										=      []
								_lowerCAmelCase    :    Tuple										=      []
								for batch in data_loader:
												_lowerCAmelCase    :    Dict										=      batch["""input_ids"""].shape
												_lowerCAmelCase    :    Optional[int]										=      src_shape[0]
												assert bs % required_batch_size_multiple == 0 or bs < required_batch_size_multiple
												_lowerCAmelCase    :    Dict										=      np.product(batch["""input_ids"""].shape      )
												num_src_per_batch.append(_UpperCAmelCase      )
												if num_src_tokens > (max_tokens * 1.1):
																failures.append(_UpperCAmelCase      )
								assert num_src_per_batch[0] == max(_UpperCAmelCase      )
								if failures:
												raise AssertionError(f"too many tokens in {len(_UpperCAmelCase      )} batches"      )



				def       SCREAMING_SNAKE_CASE       (      self      :		List[Any]      )  ->    str:





								'''simple docstring'''




								_lowerCAmelCase					,    _lowerCAmelCase					,    _lowerCAmelCase    :    Union[str, Any]										=      self._get_dataset(max_len=512      )
								_lowerCAmelCase    :    List[Any]										=      2
								_lowerCAmelCase    :    Tuple										=      ds.make_sortish_sampler(_UpperCAmelCase		,	shuffle=_UpperCAmelCase      )

								_lowerCAmelCase    :    Dict										=      DataLoader(_UpperCAmelCase		,	batch_size=_UpperCAmelCase		,	collate_fn=ds.collate_fn		,	num_workers=2      )
								_lowerCAmelCase    :    Dict										=      DataLoader(_UpperCAmelCase		,	batch_size=_UpperCAmelCase		,	collate_fn=ds.collate_fn		,	num_workers=2		,	sampler=_UpperCAmelCase      )

								_lowerCAmelCase    :    Dict										=      tokenizer.pad_token_id

								def count_pad_tokens(_UpperCAmelCase      :		Optional[Any]		,	_UpperCAmelCase      :		Union[str, Any]="input_ids"      ):
												return [batch[k].eq(_UpperCAmelCase      ).sum().item() for batch in data_loader]

								assert sum(count_pad_tokens(_UpperCAmelCase		,	k="""labels"""      )      ) < sum(count_pad_tokens(_UpperCAmelCase		,	k="""labels"""      )      )
								assert sum(count_pad_tokens(_UpperCAmelCase      )      ) < sum(count_pad_tokens(_UpperCAmelCase      )      )
								assert len(_UpperCAmelCase      ) == len(_UpperCAmelCase      )



				def       SCREAMING_SNAKE_CASE       (      self      :		Any		,	_UpperCAmelCase      :		str=1000		,	_UpperCAmelCase      :		Dict=128      )  ->    Dict:





								'''simple docstring'''




								if os.getenv("""USE_REAL_DATA"""		,	_UpperCAmelCase      ):
												_lowerCAmelCase    :    Optional[int]										=      """examples/seq2seq/wmt_en_ro"""
												_lowerCAmelCase    :    Optional[int]										=      max_len * 2 * 64
												if not Path(_UpperCAmelCase      ).joinpath("""train.len"""      ).exists():
																save_len_file(_UpperCAmelCase		,	_UpperCAmelCase      )
								else:
												_lowerCAmelCase    :    int										=      """examples/seq2seq/test_data/wmt_en_ro"""
												_lowerCAmelCase    :    int										=      max_len * 4
												save_len_file(_UpperCAmelCase		,	_UpperCAmelCase      )

								_lowerCAmelCase    :    str										=      AutoTokenizer.from_pretrained(_UpperCAmelCase      )
								_lowerCAmelCase    :    Dict										=      SeqaSeqDataset(
								    _UpperCAmelCase		,	data_dir=_UpperCAmelCase		,	type_path="""train"""		,	max_source_length=_UpperCAmelCase		,	max_target_length=_UpperCAmelCase		,	n_obs=_UpperCAmelCase		,	)
								return ds, max_tokens, tokenizer



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





								'''simple docstring'''




								_lowerCAmelCase					,    _lowerCAmelCase					,    _lowerCAmelCase    :    Tuple										=      self._get_dataset()
								_lowerCAmelCase    :    Optional[Any]										=      set(DistributedSortishSampler(_UpperCAmelCase		,	256		,	num_replicas=2		,	rank=0		,	add_extra_examples=_UpperCAmelCase      )      )
								_lowerCAmelCase    :    Any										=      set(DistributedSortishSampler(_UpperCAmelCase		,	256		,	num_replicas=2		,	rank=1		,	add_extra_examples=_UpperCAmelCase      )      )
								assert idsa.intersection(_UpperCAmelCase      ) == set()



				@parameterized.expand(
				    [
				        MBART_TINY,
				        MARIAN_TINY,
				        T5_TINY,
				        BART_TINY,
				        PEGASUS_XSUM,
				    ]		,	)
				def       SCREAMING_SNAKE_CASE       (      self      :		str		,	_UpperCAmelCase      :		Union[str, Any]      )  ->    List[Any]:





								'''simple docstring'''




								_lowerCAmelCase    :    List[Any]										=      AutoTokenizer.from_pretrained(_UpperCAmelCase		,	use_fast=_UpperCAmelCase      )
								if tok_name == MBART_TINY:
												_lowerCAmelCase    :    Optional[Any]										=      SeqaSeqDataset(
												    _UpperCAmelCase		,	data_dir=make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()      )		,	type_path="""train"""		,	max_source_length=4		,	max_target_length=8		,	src_lang="""EN"""		,	tgt_lang="""FR"""		,	)
												_lowerCAmelCase    :    Tuple										=      train_dataset.dataset_kwargs
												assert "src_lang" in kwargs and "tgt_lang" in kwargs
								else:
												_lowerCAmelCase    :    Dict										=      SeqaSeqDataset(
												    _UpperCAmelCase		,	data_dir=make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()      )		,	type_path="""train"""		,	max_source_length=4		,	max_target_length=8		,	)
												_lowerCAmelCase    :    Optional[Any]										=      train_dataset.dataset_kwargs
												assert "add_prefix_space" not in kwargs if tok_name != BART_TINY else "add_prefix_space" in kwargs
												assert len(_UpperCAmelCase      ) == 1 if tok_name == BART_TINY else len(_UpperCAmelCase      ) == 0

