






"""simple docstring"""
import argparse
import struct
import unittest







class      UpperCamelCase_			:





	def __init__( self   :					List[str]      ,      lowerCAmelCase_   :					bytes		)		->     None:
				UpperCAmelCase_	:					Optional[Any]     	=   data

				# Initialize hash values
				UpperCAmelCase_	:					Union[str, Any]     	=   [
				    0X6A09_E667,
				    0XBB67_AE85,
				    0X3C6E_F372,
				    0XA54F_F53A,
				    0X510E_527F,
				    0X9B05_688C,
				    0X1F83_D9AB,
				    0X5BE0_CD19,
				]

				# Initialize round constants
				UpperCAmelCase_	:					Any     	=   [
				    0X428A_2F98,
				    0X7137_4491,
				    0XB5C0_FBCF,
				    0XE9B5_DBA5,
				    0X3956_C25B,
				    0X59F1_11F1,
				    0X923F_82A4,
				    0XAB1C_5ED5,
				    0XD807_AA98,
				    0X1283_5B01,
				    0X2431_85BE,
				    0X550C_7DC3,
				    0X72BE_5D74,
				    0X80DE_B1FE,
				    0X9BDC_06A7,
				    0XC19B_F174,
				    0XE49B_69C1,
				    0XEFBE_4786,
				    0X0FC1_9DC6,
				    0X240C_A1CC,
				    0X2DE9_2C6F,
				    0X4A74_84AA,
				    0X5CB0_A9DC,
				    0X76F9_88DA,
				    0X983E_5152,
				    0XA831_C66D,
				    0XB003_27C8,
				    0XBF59_7FC7,
				    0XC6E0_0BF3,
				    0XD5A7_9147,
				    0X06CA_6351,
				    0X1429_2967,
				    0X27B7_0A85,
				    0X2E1B_2138,
				    0X4D2C_6DFC,
				    0X5338_0D13,
				    0X650A_7354,
				    0X766A_0ABB,
				    0X81C2_C92E,
				    0X9272_2C85,
				    0XA2BF_E8A1,
				    0XA81A_664B,
				    0XC24B_8B70,
				    0XC76C_51A3,
				    0XD192_E819,
				    0XD699_0624,
				    0XF40E_3585,
				    0X106A_A070,
				    0X19A4_C116,
				    0X1E37_6C08,
				    0X2748_774C,
				    0X34B0_BCB5,
				    0X391C_0CB3,
				    0X4ED8_AA4A,
				    0X5B9C_CA4F,
				    0X682E_6FF3,
				    0X748F_82EE,
				    0X78A5_636F,
				    0X84C8_7814,
				    0X8CC7_0208,
				    0X90BE_FFFA,
				    0XA450_6CEB,
				    0XBEF9_A3F7,
				    0XC671_78F2,
				]

				UpperCAmelCase_	:					List[str]     	=   self.preprocessing(self.data		)
				self.final_hash()





	@staticmethod
	def 	_SCREAMING_SNAKE_CASE ( lowerCAmelCase_   :					bytes		)		->     bytes:
				UpperCAmelCase_	:					List[Any]     	=   b"\x80" + (b"\x00" * (63 - (len(lowerCAmelCase_		) + 8) % 64))
				UpperCAmelCase_	:					int     	=   struct.pack(">Q"      ,      (len(lowerCAmelCase_		) * 8)		)
				return data + padding + big_endian_integer





	def 	_SCREAMING_SNAKE_CASE ( self   :					Dict		)		->     None:
				# Convert into blocks of 64 bytes
				UpperCAmelCase_	:					str     	=   [
				    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
							UpperCAmelCase_	:					Optional[Any]     	=   list(struct.unpack(">16L"      ,      lowerCAmelCase_		)		)
							# add 48 0-ed integers
							words += [0] * 48

							UpperCAmelCase_	,      UpperCAmelCase_	,      UpperCAmelCase_	,      UpperCAmelCase_	,      UpperCAmelCase_	,      UpperCAmelCase_	,      UpperCAmelCase_	,      UpperCAmelCase_	:					Union[str, Any]     	=   self.hashes

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

													UpperCAmelCase_	:					int     	=   (
													    words[index - 16] + sa + words[index - 7] + sa
													) % 0X1_0000_0000

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

										UpperCAmelCase_	,      UpperCAmelCase_	,      UpperCAmelCase_	,      UpperCAmelCase_	,      UpperCAmelCase_	,      UpperCAmelCase_	,      UpperCAmelCase_	,      UpperCAmelCase_	:					Union[str, Any]     	=   (
										    g,
										    f,
										    e,
										    ((d + tempa) % 0X1_0000_0000),
										    c,
										    b,
										    a,
										    ((tempa + tempa) % 0X1_0000_0000),
										)

							UpperCAmelCase_	:					Optional[Any]     	=   [a, b, c, d, e, f, g, h]

							# Modify final values
							UpperCAmelCase_	:					Any     	=   [
							    ((element + mutated_hash_values[index]) % 0X1_0000_0000)
							    for index, element in enumerate(self.hashes		)
							]

				UpperCAmelCase_	:					Optional[Any]     	=   "".join([hex(lowerCAmelCase_		)[2:].zfill(8		) for value in self.hashes]		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					List[str]      ,      lowerCAmelCase_   :					int      ,      lowerCAmelCase_   :					int		)		->     int:
				return 0XFFFF_FFFF & (value << (32 - rotations)) | (value >> rotations)







class      UpperCamelCase_			(unittest.TestCase	):





	def 	_SCREAMING_SNAKE_CASE ( self   :					Optional[int]		)		->     None:
				import hashlib

				UpperCAmelCase_	:					Union[str, Any]     	=   bytes("Test String"      ,      "utf-8"		)
				self.assertEqual(SHAaaa(lowerCAmelCase_		).hash      ,      hashlib.shaaaa(lowerCAmelCase_		).hexdigest()		)





def 							snake_case (  ):
			import doctest

			doctest.testmod()

			UpperCAmelCase_	:					Any     	=   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"		)

			UpperCAmelCase_	:					Union[str, Any]     	=   parser.parse_args()

			UpperCAmelCase_	:					Optional[int]     	=   args.input_string

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

			print(SHAaaa(A__		).hash		)


if __name__ == "__main__":
			main()






import math
import os
import unittest

from transformers import MegatronBertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    MODEL_FOR_PRETRAINING_MAPPING,
	    MegatronBertForCausalLM,
	    MegatronBertForMaskedLM,
	    MegatronBertForMultipleChoice,
	    MegatronBertForNextSentencePrediction,
	    MegatronBertForPreTraining,
	    MegatronBertForQuestionAnswering,
	    MegatronBertForSequenceClassification,
	    MegatronBertForTokenClassification,
	    MegatronBertModel,
	)



class        _a		:


					'''simple docstring'''






					def __init__(					self       ,			A__       ,			A__=13       ,			A__=7       ,			A__=True       ,			A__=True       ,			A__=True       ,			A__=True       ,			A__=99       ,			A__=64       ,			A__=32       ,			A__=5       ,			A__=4       ,			A__=37       ,			A__="gelu"       ,			A__=0.1       ,			A__=0.1       ,			A__=512       ,			A__=16       ,			A__=2       ,			A__=0.0_2       ,			A__=3       ,			A__=4       ,			A__=None       ,			):
						A__				:       int	  =						parent
						A__				:       Optional[Any]	  =						batch_size
						A__				:       Optional[Any]	  =						seq_length
						A__				:       Any	  =						is_training
						A__				:       Tuple	  =						use_input_mask
						A__				:       Optional[int]	  =						use_token_type_ids
						A__				:       Tuple	  =						use_labels
						A__				:       Union[str, Any]	  =						vocab_size
						A__				:       List[Any]	  =						hidden_size
						A__				:       Optional[Any]	  =						embedding_size
						A__				:       Optional[int]	  =						num_hidden_layers
						A__				:       Any	  =						num_attention_heads
						A__				:       Tuple	  =						intermediate_size
						A__				:       Tuple	  =						hidden_act
						A__				:       Dict	  =						hidden_dropout_prob
						A__				:       Union[str, Any]	  =						attention_probs_dropout_prob
						A__				:       Optional[Any]	  =						max_position_embeddings
						A__				:       Tuple	  =						type_vocab_size
						A__				:       Optional[Any]	  =						type_sequence_label_size
						A__				:       str	  =						initializer_range
						A__				:       Any	  =						num_labels
						A__				:       Dict	  =						num_choices
						A__				:       List[str]	  =						scope






					def     __A     (					self     ):
						A__				:       Tuple	  =						ids_tensor([self.batch_size, self.seq_length]       ,			self.vocab_size     )

						A__				:       Any	  =						None
						if self.use_input_mask:
							A__				:       Dict	  =						random_attention_mask([self.batch_size, self.seq_length]     )

						A__				:       List[str]	  =						None
						if self.use_token_type_ids:
							A__				:       Any	  =						ids_tensor([self.batch_size, self.seq_length]       ,			self.type_vocab_size     )

						A__				:       Any	  =						None
						A__				:       str	  =						None
						A__				:       Dict	  =						None
						if self.use_labels:
							A__				:       str	  =						ids_tensor([self.batch_size]       ,			self.type_sequence_label_size     )
							A__				:       Optional[int]	  =						ids_tensor([self.batch_size, self.seq_length]       ,			self.num_labels     )
							A__				:       Union[str, Any]	  =						ids_tensor([self.batch_size]       ,			self.num_choices     )

						A__				:       Optional[int]	  =						self.get_config()

						return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






					def     __A     (					self     ):
						return MegatronBertConfig(
						    vocab_size=self.vocab_size       ,			hidden_size=self.hidden_size       ,			num_hidden_layers=self.num_hidden_layers       ,			num_attention_heads=self.num_attention_heads       ,			intermediate_size=self.intermediate_size       ,			embedding_size=self.embedding_size       ,			hidden_act=self.hidden_act       ,			hidden_dropout_prob=self.hidden_dropout_prob       ,			attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,			max_position_embeddings=self.max_position_embeddings       ,			type_vocab_size=self.type_vocab_size       ,			is_decoder=A__       ,			initializer_range=self.initializer_range       ,			)






					def     __A     (					self       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__     ):
						A__				:       Dict	  =						MegatronBertModel(config=A__     )
						model.to(A__     )
						model.eval()
						A__				:       str	  =						model(A__       ,			attention_mask=A__       ,			token_type_ids=A__     )
						A__				:       Optional[Any]	  =						model(A__       ,			token_type_ids=A__     )
						A__				:       Dict	  =						model(A__     )

						self.parent.assertEqual(result.last_hidden_state.shape       ,			(self.batch_size, self.seq_length, self.hidden_size)     )
						self.parent.assertEqual(result.pooler_output.shape       ,			(self.batch_size, self.hidden_size)     )






					def     __A     (					self       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__     ):
						A__				:       str	  =						MegatronBertForMaskedLM(config=A__     )
						model.to(A__     )
						model.eval()
						A__				:       List[Any]	  =						model(A__       ,			attention_mask=A__       ,			token_type_ids=A__       ,			labels=A__     )
						self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, self.seq_length, self.vocab_size)     )






					def     __A     (					self       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__     ):
						A__				:       Tuple	  =						MegatronBertForCausalLM(config=A__     )
						model.to(A__     )
						model.eval()
						A__				:       int	  =						model(A__       ,			attention_mask=A__       ,			token_type_ids=A__       ,			labels=A__     )
						self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, self.seq_length, self.vocab_size)     )






					def     __A     (					self       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__     ):
						A__				:       Dict	  =						MegatronBertForNextSentencePrediction(config=A__     )
						model.to(A__     )
						model.eval()
						A__				:       Optional[int]	  =						model(
						    A__       ,			attention_mask=A__       ,			token_type_ids=A__       ,			labels=A__       ,			)
						self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, 2)     )






					def     __A     (					self       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__     ):
						A__				:       Optional[Any]	  =						MegatronBertForPreTraining(config=A__     )
						model.to(A__     )
						model.eval()
						A__				:       List[str]	  =						model(
						    A__       ,			attention_mask=A__       ,			token_type_ids=A__       ,			labels=A__       ,			next_sentence_label=A__       ,			)
						self.parent.assertEqual(result.prediction_logits.shape       ,			(self.batch_size, self.seq_length, self.vocab_size)     )
						self.parent.assertEqual(result.seq_relationship_logits.shape       ,			(self.batch_size, 2)     )






					def     __A     (					self       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__     ):
						A__				:       Optional[Any]	  =						MegatronBertForQuestionAnswering(config=A__     )
						model.to(A__     )
						model.eval()
						A__				:       Optional[Any]	  =						model(
						    A__       ,			attention_mask=A__       ,			token_type_ids=A__       ,			start_positions=A__       ,			end_positions=A__       ,			)
						self.parent.assertEqual(result.start_logits.shape       ,			(self.batch_size, self.seq_length)     )
						self.parent.assertEqual(result.end_logits.shape       ,			(self.batch_size, self.seq_length)     )






					def     __A     (					self       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__     ):
						A__				:       Optional[int]	  =						self.num_labels
						A__				:       Union[str, Any]	  =						MegatronBertForSequenceClassification(A__     )
						model.to(A__     )
						model.eval()
						A__				:       List[str]	  =						model(A__       ,			attention_mask=A__       ,			token_type_ids=A__       ,			labels=A__     )
						self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, self.num_labels)     )






					def     __A     (					self       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__     ):
						A__				:       Union[str, Any]	  =						self.num_labels
						A__				:       int	  =						MegatronBertForTokenClassification(config=A__     )
						model.to(A__     )
						model.eval()
						A__				:       Optional[int]	  =						model(A__       ,			attention_mask=A__       ,			token_type_ids=A__       ,			labels=A__     )
						self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, self.seq_length, self.num_labels)     )






					def     __A     (					self       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__       ,			A__     ):
						A__				:       Any	  =						self.num_choices
						A__				:       Dict	  =						MegatronBertForMultipleChoice(config=A__     )
						model.to(A__     )
						model.eval()
						A__				:       Optional[Any]	  =						input_ids.unsqueeze(1     ).expand(-1       ,			self.num_choices       ,			-1     ).contiguous()
						A__				:       str	  =						token_type_ids.unsqueeze(1     ).expand(-1       ,			self.num_choices       ,			-1     ).contiguous()
						A__				:       int	  =						input_mask.unsqueeze(1     ).expand(-1       ,			self.num_choices       ,			-1     ).contiguous()
						A__				:       Optional[Any]	  =						model(
						    A__       ,			attention_mask=A__       ,			token_type_ids=A__       ,			labels=A__       ,			)
						self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, self.num_choices)     )






					def     __A     (					self     ):
						A__				:       Optional[Any]	  =						self.prepare_config_and_inputs()
						(
						    (
						    A__
						)  ,  (
						    A__
						)  ,  (
						    A__
						)  ,  (
						    A__
						)  ,  (
						    A__
						)  ,  (
						    A__
						)  ,  (
						    A__
						)  ,  
						)				:       Any	  =						config_and_inputs
						A__				:       Any	  =						{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
						return config, inputs_dict



@require_torch
class        _a		(__magic_name__						,  __magic_name__						,  unittest.TestCase							):


					'''simple docstring'''






					UpperCAmelCase__:  Optional[Any]    				=			(
					    (
					        MegatronBertModel,
					        MegatronBertForMaskedLM,
					        MegatronBertForCausalLM,
					        MegatronBertForMultipleChoice,
					        MegatronBertForNextSentencePrediction,
					        MegatronBertForPreTraining,
					        MegatronBertForQuestionAnswering,
					        MegatronBertForSequenceClassification,
					        MegatronBertForTokenClassification,
					    )
					    if is_torch_available()
					    else ()
					)
					UpperCAmelCase__:  Tuple    				=			(
					    {
					        '''feature-extraction''': MegatronBertModel,
					        '''fill-mask''': MegatronBertForMaskedLM,
					        '''question-answering''': MegatronBertForQuestionAnswering,
					        '''text-classification''': MegatronBertForSequenceClassification,
					        '''text-generation''': MegatronBertForCausalLM,
					        '''token-classification''': MegatronBertForTokenClassification,
					        '''zero-shot''': MegatronBertForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					UpperCAmelCase__:  int    				=			True
					# test_resize_embeddings = False
					UpperCAmelCase__:  List[str]    				=			False






					def     __A     (					self       ,			A__       ,			A__       ,			A__=False     ):
						A__				:       Union[str, Any]	  =						super()._prepare_for_class(A__       ,			A__       ,			return_labels=A__     )

						if return_labels:
							if model_class in get_values(A__     ):
								A__				:       str	  =						torch.zeros(
								    (self.model_tester.batch_size, self.model_tester.seq_length)       ,			dtype=torch.long       ,			device=A__     )
								A__				:       Union[str, Any]	  =						torch.zeros(
								    self.model_tester.batch_size       ,			dtype=torch.long       ,			device=A__     )
						return inputs_dict






					def     __A     (					self     ):
						A__				:       Union[str, Any]	  =						MegatronBertModelTester(self     )
						A__				:       Union[str, Any]	  =						ConfigTester(self       ,			config_class=A__       ,			hidden_size=37     )






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






					def     __A     (					self     ):
						A__				:       List[str]	  =						self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_megatron_bert_model(*A__     )






					def     __A     (					self     ):
						A__				:       Dict	  =						self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_megatron_bert_for_masked_lm(*A__     )






					def     __A     (					self     ):
						A__				:       Tuple	  =						self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_megatron_bert_for_multiple_choice(*A__     )






					def     __A     (					self     ):
						A__				:       Dict	  =						self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_megatron_bert_for_next_sequence_prediction(*A__     )






					def     __A     (					self     ):
						A__				:       Union[str, Any]	  =						self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_megatron_bert_for_pretraining(*A__     )






					def     __A     (					self     ):
						A__				:       Dict	  =						self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_megatron_bert_for_question_answering(*A__     )






					def     __A     (					self     ):
						A__				:       int	  =						self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_megatron_bert_for_sequence_classification(*A__     )






					def     __A     (					self     ):
						A__				:       Tuple	  =						self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_megatron_bert_for_token_classification(*A__     )



def 		UpperCamelCase   (lowercase_:					Optional[int]   )	-> List[Any]:
	return torch.tensor(
	    lowercase_       , dtype=torch.long       , device=lowercase_       , )


A_			:					int    			=     1E-4



@require_torch
@require_sentencepiece
@require_tokenizers
class        _a		(unittest.TestCase							):


					'''simple docstring'''






					@slow
					@unittest.skip("""Model is not available."""     )
					def     __A     (					self     ):
						A__				:       int	  =						"""nvidia/megatron-bert-uncased-345m"""
						if "MYDIR" in os.environ:
							A__				:       Dict	  =						os.path.join(os.environ["""MYDIR"""]       ,			A__     )
						A__				:       List[str]	  =						MegatronBertModel.from_pretrained(A__     )
						model.to(A__     )
						model.half()
						A__				:       Union[str, Any]	  =						_long_tensor([[101, 7110, 1005, 1056, 2023, 1_1333, 1_7413, 1029, 102]]     )
						with torch.no_grad():
							A__				:       Dict	  =						model(A__     )[0]
						A__				:       List[Any]	  =						torch.Size((1, 9, 1024)     )
						self.assertEqual(output.shape       ,			A__     )

						A__				:       int	  =						[-0.6_0_4_0, -0.2_5_1_7, -0.1_0_2_5, 0.3_4_2_0, -0.6_7_5_8, -0.0_0_1_7, -0.1_0_8_9, -0.1_9_9_0, 0.5_7_2_8]
						for ii in range(3     ):
							for jj in range(3     ):
								A__				:       List[Any]	  =						output[0, ii, jj]
								A__				:       Dict	  =						expected[3 * ii + jj]
								A__				:       Dict	  =						"""ii={} jj={} a={} b={}""".format(A__       ,			A__       ,			A__       ,			A__     )
								self.assertTrue(math.isclose(A__       ,			A__       ,			rel_tol=A__       ,			abs_tol=A__     )       ,			msg=A__     )



