

import logging
import os
from dataclasses import dataclass, field
from typing import Dict, Optional

import datasets
import numpy as np
import tensorflow as tf

from transformers import (
    AutoConfig,
    AutoTokenizer,
    EvalPrediction,
    HfArgumentParser,
    PreTrainedTokenizer,
    TFAutoModelForSequenceClassification,
    TFTrainer,
    TFTrainingArguments,
)
from transformers.utils import logging as hf_logging


hf_logging.set_verbosity_info()
hf_logging.enable_default_handler()
hf_logging.enable_explicit_format()

def 							__SCREAMING_SNAKE_CASE							(			lowerCAmelCase:					str					, lowerCAmelCase:					str					, lowerCAmelCase:					str					, lowerCAmelCase:					PreTrainedTokenizer					, lowerCAmelCase:					int					, lowerCAmelCase:					Optional[int] = None					, )				->    str:
				_UpperCAmelCase    :						List[Any]							=      {}

				if train_file is not None:
								_UpperCAmelCase    :						Dict							=      [train_file]
				if eval_file is not None:
								_UpperCAmelCase    :						str							=      [eval_file]
				if test_file is not None:
								_UpperCAmelCase    :						Union[str, Any]							=      [test_file]

				_UpperCAmelCase    :						int							=      datasets.load_dataset("csv"					, data_files=lowerCAmelCase	)
				_UpperCAmelCase    :						Any							=      list(ds[list(files.keys()	)[0]].features.keys()	)
				_UpperCAmelCase    :						Dict							=      features_name.pop(lowerCAmelCase	)
				_UpperCAmelCase    :						Any							=      list(set(ds[list(files.keys()	)[0]][label_name]	)	)
				_UpperCAmelCase    :						int							=      {label: i for i, label in enumerate(lowerCAmelCase	)}
				_UpperCAmelCase    :						List[Any]							=      tokenizer.model_input_names
				_UpperCAmelCase    :						List[str]							=      {}

				if len(lowerCAmelCase	) == 1:
								for k in files.keys():
												_UpperCAmelCase    :						List[Any]							=      ds[k].map(
												    lambda lowerCAmelCase	: tokenizer.batch_encode_plus(
												        example[features_name[0]]					, truncation=lowerCAmelCase					, max_length=lowerCAmelCase					, padding="max_length"	)					, batched=lowerCAmelCase					, )
				elif len(lowerCAmelCase	) == 2:
								for k in files.keys():
												_UpperCAmelCase    :						Tuple							=      ds[k].map(
												    lambda lowerCAmelCase	: tokenizer.batch_encode_plus(
												        (example[features_name[0]], example[features_name[1]])					, truncation=lowerCAmelCase					, max_length=lowerCAmelCase					, padding="max_length"					, )					, batched=lowerCAmelCase					, )

				def gen_train():
								for ex in transformed_ds[datasets.Split.TRAIN]:
												_UpperCAmelCase    :						Optional[Any]							=      {k: v for k, v in ex.items() if k in input_names}
												_UpperCAmelCase    :						Union[str, Any]							=      labelaid[ex[label_name]]
												yield (d, label)

				def gen_val():
								for ex in transformed_ds[datasets.Split.VALIDATION]:
												_UpperCAmelCase    :						Dict							=      {k: v for k, v in ex.items() if k in input_names}
												_UpperCAmelCase    :						str							=      labelaid[ex[label_name]]
												yield (d, label)

				def gen_test():
								for ex in transformed_ds[datasets.Split.TEST]:
												_UpperCAmelCase    :						List[str]							=      {k: v for k, v in ex.items() if k in input_names}
												_UpperCAmelCase    :						str							=      labelaid[ex[label_name]]
												yield (d, label)

				_UpperCAmelCase    :						Optional[int]							=      (
				    tf.data.Dataset.from_generator(
				        lowerCAmelCase					, ({k: tf.intaa for k in input_names}, tf.intaa)					, ({k: tf.TensorShape([None]	) for k in input_names}, tf.TensorShape([]	))					, )
				    if datasets.Split.TRAIN in transformed_ds
				    else None
				)

				if train_ds is not None:
								_UpperCAmelCase    :						str							=      train_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TRAIN]	)	)	)

				_UpperCAmelCase    :						Optional[Any]							=      (
				    tf.data.Dataset.from_generator(
				        lowerCAmelCase					, ({k: tf.intaa for k in input_names}, tf.intaa)					, ({k: tf.TensorShape([None]	) for k in input_names}, tf.TensorShape([]	))					, )
				    if datasets.Split.VALIDATION in transformed_ds
				    else None
				)

				if val_ds is not None:
								_UpperCAmelCase    :						int							=      val_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.VALIDATION]	)	)	)

				_UpperCAmelCase    :						Optional[Any]							=      (
				    tf.data.Dataset.from_generator(
				        lowerCAmelCase					, ({k: tf.intaa for k in input_names}, tf.intaa)					, ({k: tf.TensorShape([None]	) for k in input_names}, tf.TensorShape([]	))					, )
				    if datasets.Split.TEST in transformed_ds
				    else None
				)

				if test_ds is not None:
								_UpperCAmelCase    :						Dict							=      test_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TEST]	)	)	)

				return train_ds, val_ds, test_ds, labelaid


SCREAMING_SNAKE_CASE_            = logging.getLogger(__name__)

@dataclass
class 			a					:
						_lowercase        =     field(metadata={"help": "Which column contains the label"}			)
						_lowercase        =     field(default=UpperCAmelCase							,	metadata={"help": "The path of the training file"}			)
						_lowercase        =     field(default=UpperCAmelCase							,	metadata={"help": "The path of the development file"}			)
						_lowercase        =     field(default=UpperCAmelCase							,	metadata={"help": "The path of the test file"}			)
						_lowercase        =     field(
						    default=1_2_8							,	metadata={
						        "help": (
						            "The maximum total input sequence length after tokenization. Sequences longer "
						            "than this will be truncated, sequences shorter will be padded."
						        )
						    }							,	)
						_lowercase        =     field(
						    default=UpperCAmelCase							,	metadata={"help": "Overwrite the cached training and evaluation sets"}			)







@dataclass
class 			a					:
						_lowercase        =     field(
						    metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}			)
						_lowercase        =     field(
						    default=UpperCAmelCase							,	metadata={"help": "Pretrained config name or path if not the same as model_name"}			)
						_lowercase        =     field(
						    default=UpperCAmelCase							,	metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}			)
						_lowercase        =     field(default=UpperCAmelCase							,	metadata={"help": "Set this flag to use fast tokenization."}			)
						# If you want to tweak more attributes on your tokenizer, you should do it in a distinct script,
						# or just modify its tokenizer_config.json.
						_lowercase        =     field(
						    default=UpperCAmelCase							,	metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"}							,	)







def 							__SCREAMING_SNAKE_CASE							(			)				->    Optional[Any]:
				# 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.
				_UpperCAmelCase    :						Dict							=      HfArgumentParser((ModelArguments, DataTrainingArguments, TFTrainingArguments)	)
				_UpperCAmelCase						,							_UpperCAmelCase						,							_UpperCAmelCase    :						Optional[int]							=      parser.parse_args_into_dataclasses()

				if (
				    os.path.exists(training_args.output_dir	)
				    and os.listdir(training_args.output_dir	)
				    and training_args.do_train
				    and not training_args.overwrite_output_dir
				):
								raise ValueError(
								    F'Output directory ({training_args.output_dir}) already exists and is not empty. Use'
								    " --overwrite_output_dir to overcome."	)

				# Setup logging
				logging.basicConfig(
				    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"					, datefmt="%m/%d/%Y %H:%M:%S"					, level=logging.INFO					, )
				logger.info(
				    F'n_replicas: {training_args.n_replicas}, distributed training: {bool(training_args.n_replicas > 1	)}, '
				    F'16-bits training: {training_args.fpaa}'	)
				logger.info(F'Training/evaluation parameters {training_args}'	)

				# Load pretrained model and tokenizer
				#
				# Distributed training:
				# The .from_pretrained methods guarantee that only one local process can concurrently
				# download model & vocab.

				_UpperCAmelCase    :						int							=      AutoTokenizer.from_pretrained(
				    model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path					, cache_dir=model_args.cache_dir					, )

				_UpperCAmelCase						,							_UpperCAmelCase						,							_UpperCAmelCase						,							_UpperCAmelCase    :						List[Any]							=      get_tfds(
				    train_file=data_args.train_file					, eval_file=data_args.dev_file					, test_file=data_args.test_file					, tokenizer=lowerCAmelCase					, label_column_id=data_args.label_column_id					, max_seq_length=data_args.max_seq_length					, )

				_UpperCAmelCase    :						int							=      AutoConfig.from_pretrained(
				    model_args.config_name if model_args.config_name else model_args.model_name_or_path					, num_labels=len(lowerCAmelCase	)					, labelaid=lowerCAmelCase					, idalabel={id: label for label, id in labelaid.items()}					, finetuning_task="text-classification"					, cache_dir=model_args.cache_dir					, )

				with training_args.strategy.scope():
								_UpperCAmelCase    :						Union[str, Any]							=      TFAutoModelForSequenceClassification.from_pretrained(
								    model_args.model_name_or_path					, from_pt=bool(".bin" in model_args.model_name_or_path	)					, config=lowerCAmelCase					, cache_dir=model_args.cache_dir					, )

				def compute_metrics(lowerCAmelCase:					EvalPrediction	) -> Dict:
								_UpperCAmelCase    :						List[Any]							=      np.argmax(p.predictions					, axis=1	)

								return {"acc": (preds == p.label_ids).mean()}

				# Initialize our Trainer
				_UpperCAmelCase    :						Dict							=      TFTrainer(
				    model=lowerCAmelCase					, args=lowerCAmelCase					, train_dataset=lowerCAmelCase					, eval_dataset=lowerCAmelCase					, compute_metrics=lowerCAmelCase					, )

				# Training
				if training_args.do_train:
								trainer.train()
								trainer.save_model()
								tokenizer.save_pretrained(training_args.output_dir	)

				# Evaluation
				_UpperCAmelCase    :						Tuple							=      {}
				if training_args.do_eval:
								logger.info("*** Evaluate ***"	)
								_UpperCAmelCase    :						List[Any]							=      trainer.evaluate()
								_UpperCAmelCase    :						Optional[int]							=      os.path.join(training_args.output_dir					, "eval_results.txt"	)

								with open(lowerCAmelCase					, "w"	) as writer:
												logger.info("***** Eval results *****"	)

												for key, value in result.items():
																logger.info(F'  {key} = {value}'	)
																writer.write(F'{key} = {value}\n'	)

												results.update(lowerCAmelCase	)

				return results


if __name__ == "__main__":
					main()





import tempfile

import torch

from diffusers import PNDMScheduler

from .test_schedulers import SchedulerCommonTest

class 			a					(		UpperCAmelCase			):
						_lowercase        =     (PNDMScheduler,)
						_lowercase        =     (("num_inference_steps", 5_0),)


						def     _UpperCAmelCase			(    self  ,   **A_		):







										'''simple docstring'''


										_UpperCAmelCase    :						Tuple							=      {
										    "num_train_timesteps": 1000,
										    "beta_start": 0.00_01,
										    "beta_end": 0.02,
										    "beta_schedule": "linear",
										}

										config.update(**A_		)
										return config


						def     _UpperCAmelCase			(    self  ,   A_=0  ,   **A_		):







										'''simple docstring'''


										_UpperCAmelCase    :						int							=      dict(self.forward_default_kwargs		)
										_UpperCAmelCase    :						Optional[Any]							=      kwargs.pop("num_inference_steps"  ,   A_		)
										_UpperCAmelCase    :						int							=      self.dummy_sample
										_UpperCAmelCase    :						Dict							=      0.1 * sample
										_UpperCAmelCase    :						Optional[int]							=      [residual + 0.2, residual + 0.15, residual + 0.1, residual + 0.05]

										for scheduler_class in self.scheduler_classes:
														_UpperCAmelCase    :						Dict							=      self.get_scheduler_config(**A_		)
														_UpperCAmelCase    :						Any							=      scheduler_class(**A_		)
														scheduler.set_timesteps(A_		)
														# copy over dummy past residuals
														_UpperCAmelCase    :						Union[str, Any]							=      dummy_past_residuals[:]

														with tempfile.TemporaryDirectory() as tmpdirname:
																		scheduler.save_config(A_		)
																		_UpperCAmelCase    :						str							=      scheduler_class.from_pretrained(A_		)
																		new_scheduler.set_timesteps(A_		)
																		# copy over dummy past residuals
																		_UpperCAmelCase    :						Union[str, Any]							=      dummy_past_residuals[:]

														_UpperCAmelCase    :						Tuple							=      scheduler.step_prk(A_  ,   A_  ,   A_  ,   **A_		).prev_sample
														_UpperCAmelCase    :						Any							=      new_scheduler.step_prk(A_  ,   A_  ,   A_  ,   **A_		).prev_sample

														assert torch.sum(torch.abs(output - new_output		)		) < 1e-5, "Scheduler outputs are not identical"

														_UpperCAmelCase    :						Union[str, Any]							=      scheduler.step_plms(A_  ,   A_  ,   A_  ,   **A_		).prev_sample
														_UpperCAmelCase    :						Optional[Any]							=      new_scheduler.step_plms(A_  ,   A_  ,   A_  ,   **A_		).prev_sample

														assert torch.sum(torch.abs(output - new_output		)		) < 1e-5, "Scheduler outputs are not identical"


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										pass


						def     _UpperCAmelCase			(    self  ,   A_=0  ,   **A_		):







										'''simple docstring'''


										_UpperCAmelCase    :						Any							=      dict(self.forward_default_kwargs		)
										_UpperCAmelCase    :						int							=      kwargs.pop("num_inference_steps"  ,   A_		)
										_UpperCAmelCase    :						int							=      self.dummy_sample
										_UpperCAmelCase    :						Any							=      0.1 * sample
										_UpperCAmelCase    :						Tuple							=      [residual + 0.2, residual + 0.15, residual + 0.1, residual + 0.05]

										for scheduler_class in self.scheduler_classes:
														_UpperCAmelCase    :						Optional[Any]							=      self.get_scheduler_config()
														_UpperCAmelCase    :						Dict							=      scheduler_class(**A_		)
														scheduler.set_timesteps(A_		)

														# copy over dummy past residuals (must be after setting timesteps)
														_UpperCAmelCase    :						Any							=      dummy_past_residuals[:]

														with tempfile.TemporaryDirectory() as tmpdirname:
																		scheduler.save_config(A_		)
																		_UpperCAmelCase    :						str							=      scheduler_class.from_pretrained(A_		)
																		# copy over dummy past residuals
																		new_scheduler.set_timesteps(A_		)

																		# copy over dummy past residual (must be after setting timesteps)
																		_UpperCAmelCase    :						List[Any]							=      dummy_past_residuals[:]

														_UpperCAmelCase    :						Tuple							=      scheduler.step_prk(A_  ,   A_  ,   A_  ,   **A_		).prev_sample
														_UpperCAmelCase    :						Union[str, Any]							=      new_scheduler.step_prk(A_  ,   A_  ,   A_  ,   **A_		).prev_sample

														assert torch.sum(torch.abs(output - new_output		)		) < 1e-5, "Scheduler outputs are not identical"

														_UpperCAmelCase    :						Optional[Any]							=      scheduler.step_plms(A_  ,   A_  ,   A_  ,   **A_		).prev_sample
														_UpperCAmelCase    :						List[str]							=      new_scheduler.step_plms(A_  ,   A_  ,   A_  ,   **A_		).prev_sample

														assert torch.sum(torch.abs(output - new_output		)		) < 1e-5, "Scheduler outputs are not identical"


						def     _UpperCAmelCase			(    self  ,   **A_		):







										'''simple docstring'''


										_UpperCAmelCase    :						Optional[Any]							=      self.scheduler_classes[0]
										_UpperCAmelCase    :						Union[str, Any]							=      self.get_scheduler_config(**A_		)
										_UpperCAmelCase    :						List[str]							=      scheduler_class(**A_		)

										_UpperCAmelCase    :						List[str]							=      10
										_UpperCAmelCase    :						Optional[int]							=      self.dummy_model()
										_UpperCAmelCase    :						List[Any]							=      self.dummy_sample_deter
										scheduler.set_timesteps(A_		)

										for i, t in enumerate(scheduler.prk_timesteps		):
														_UpperCAmelCase    :						Dict							=      model(A_  ,   A_		)
														_UpperCAmelCase    :						int							=      scheduler.step_prk(A_  ,   A_  ,   A_		).prev_sample

										for i, t in enumerate(scheduler.plms_timesteps		):
														_UpperCAmelCase    :						Any							=      model(A_  ,   A_		)
														_UpperCAmelCase    :						Any							=      scheduler.step_plms(A_  ,   A_  ,   A_		).prev_sample

										return sample


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										_UpperCAmelCase    :						List[Any]							=      dict(self.forward_default_kwargs		)

										_UpperCAmelCase    :						str							=      kwargs.pop("num_inference_steps"  ,   A_		)

										for scheduler_class in self.scheduler_classes:
														_UpperCAmelCase    :						int							=      self.get_scheduler_config()
														_UpperCAmelCase    :						Optional[Any]							=      scheduler_class(**A_		)

														_UpperCAmelCase    :						int							=      self.dummy_sample
														_UpperCAmelCase    :						str							=      0.1 * sample

														if num_inference_steps is not None and hasattr(A_  ,   "set_timesteps"		):
																		scheduler.set_timesteps(A_		)
														elif num_inference_steps is not None and not hasattr(A_  ,   "set_timesteps"		):
																		_UpperCAmelCase    :						Union[str, Any]							=      num_inference_steps

														# copy over dummy past residuals (must be done after set_timesteps)
														_UpperCAmelCase    :						Tuple							=      [residual + 0.2, residual + 0.15, residual + 0.1, residual + 0.05]
														_UpperCAmelCase    :						Any							=      dummy_past_residuals[:]

														_UpperCAmelCase    :						Any							=      scheduler.step_prk(A_  ,   0  ,   A_  ,   **A_		).prev_sample
														_UpperCAmelCase    :						Optional[Any]							=      scheduler.step_prk(A_  ,   1  ,   A_  ,   **A_		).prev_sample

														self.assertEqual(output_a.shape  ,   sample.shape		)
														self.assertEqual(output_a.shape  ,   output_a.shape		)

														_UpperCAmelCase    :						Optional[int]							=      scheduler.step_plms(A_  ,   0  ,   A_  ,   **A_		).prev_sample
														_UpperCAmelCase    :						Optional[Any]							=      scheduler.step_plms(A_  ,   1  ,   A_  ,   **A_		).prev_sample

														self.assertEqual(output_a.shape  ,   sample.shape		)
														self.assertEqual(output_a.shape  ,   output_a.shape		)


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										for timesteps in [100, 1000]:
														self.check_over_configs(num_train_timesteps=A_		)


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										for steps_offset in [0, 1]:
														self.check_over_configs(steps_offset=A_		)

										_UpperCAmelCase    :						List[str]							=      self.scheduler_classes[0]
										_UpperCAmelCase    :						Optional[int]							=      self.get_scheduler_config(steps_offset=1		)
										_UpperCAmelCase    :						str							=      scheduler_class(**A_		)
										scheduler.set_timesteps(10		)
										assert torch.equal(
										    scheduler.timesteps  ,   torch.LongTensor(
										        [901, 851, 851, 801, 801, 751, 751, 701, 701, 651, 651, 601, 601, 501, 401, 301, 201, 101, 1]		)  ,   )


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										for beta_start, beta_end in zip([0.00_01, 0.0_01]  ,   [0.0_02, 0.02]		):
														self.check_over_configs(beta_start=A_  ,   beta_end=A_		)


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										for schedule in ["linear", "squaredcos_cap_v2"]:
														self.check_over_configs(beta_schedule=A_		)


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										for prediction_type in ["epsilon", "v_prediction"]:
														self.check_over_configs(prediction_type=A_		)


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										for t in [1, 5, 10]:
														self.check_over_forward(time_step=A_		)


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										for t, num_inference_steps in zip([1, 5, 10]  ,   [10, 50, 100]		):
														self.check_over_forward(num_inference_steps=A_		)


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										_UpperCAmelCase    :						int							=      27

										for scheduler_class in self.scheduler_classes:
														_UpperCAmelCase    :						str							=      self.dummy_sample
														_UpperCAmelCase    :						str							=      0.1 * sample

														_UpperCAmelCase    :						str							=      self.get_scheduler_config()
														_UpperCAmelCase    :						Tuple							=      scheduler_class(**A_		)

														scheduler.set_timesteps(A_		)

														# before power of 3 fix, would error on first step, so we only need to do two
														for i, t in enumerate(scheduler.prk_timesteps[:2]		):
																		_UpperCAmelCase    :						Dict							=      scheduler.step_prk(A_  ,   A_  ,   A_		).prev_sample


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										with self.assertRaises(A_		):
														_UpperCAmelCase    :						Union[str, Any]							=      self.scheduler_classes[0]
														_UpperCAmelCase    :						Dict							=      self.get_scheduler_config()
														_UpperCAmelCase    :						Union[str, Any]							=      scheduler_class(**A_		)

														scheduler.step_plms(self.dummy_sample  ,   1  ,   self.dummy_sample		).prev_sample


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										_UpperCAmelCase    :						Dict							=      self.full_loop()
										_UpperCAmelCase    :						int							=      torch.sum(torch.abs(A_		)		)
										_UpperCAmelCase    :						Optional[Any]							=      torch.mean(torch.abs(A_		)		)

										assert abs(result_sum.item() - 1_98.13_18		) < 1e-2
										assert abs(result_mean.item() - 0.25_80		) < 1e-3


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										_UpperCAmelCase    :						Optional[Any]							=      self.full_loop(prediction_type="v_prediction"		)
										_UpperCAmelCase    :						Union[str, Any]							=      torch.sum(torch.abs(A_		)		)
										_UpperCAmelCase    :						List[Any]							=      torch.mean(torch.abs(A_		)		)

										assert abs(result_sum.item() - 67.39_86		) < 1e-2
										assert abs(result_mean.item() - 0.08_78		) < 1e-3


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										_UpperCAmelCase    :						Tuple							=      self.full_loop(set_alpha_to_one=A_  ,   beta_start=0.01		)
										_UpperCAmelCase    :						Dict							=      torch.sum(torch.abs(A_		)		)
										_UpperCAmelCase    :						Optional[int]							=      torch.mean(torch.abs(A_		)		)

										assert abs(result_sum.item() - 2_30.03_99		) < 1e-2
										assert abs(result_mean.item() - 0.29_95		) < 1e-3





						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										_UpperCAmelCase    :						List[Any]							=      self.full_loop(set_alpha_to_one=A_  ,   beta_start=0.01		)
										_UpperCAmelCase    :						Optional[Any]							=      torch.sum(torch.abs(A_		)		)
										_UpperCAmelCase    :						Dict							=      torch.mean(torch.abs(A_		)		)

										assert abs(result_sum.item() - 1_86.94_82		) < 1e-2
										assert abs(result_mean.item() - 0.24_34		) < 1e-3


