


'''simple docstring'''






from __future__ import annotations

import unittest
from collections.abc import Iterator






class      SCREAMING_SNAKE_CASE_	:




			def __init__(      self					,      lowercase					,      lowercase       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							List[str]			   = label
								__SCREAMING_SNAKE_CASE					:							List[Any]			   = parent
								__SCREAMING_SNAKE_CASE					:							Node | None			   = None
								__SCREAMING_SNAKE_CASE					:							Node | None			   = None






class      SCREAMING_SNAKE_CASE_	:




			def __init__(      self       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Node | None			   = None




			def 			_snake_case   (      self       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							List[str]			   = None




			def 			_snake_case   (      self       )			->						bool:


								'''simple docstring'''






								return self.root is None




			def 			_snake_case   (      self					,      lowercase       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							List[str]			   = self._put(self.root					,      lowercase       )




			def 			_snake_case   (      self					,      lowercase					,      lowercase					,      lowercase = None       )			->						Node:


								'''simple docstring'''






								if node is None:
													__SCREAMING_SNAKE_CASE					:							Optional[Any]			   = Node(lowercase					,      lowercase       )
								else:
													if label < node.label:
																		__SCREAMING_SNAKE_CASE					:							Any			   = self._put(node.left					,      lowercase					,      lowercase       )
													elif label > node.label:
																		__SCREAMING_SNAKE_CASE					:							Any			   = self._put(node.right					,      lowercase					,      lowercase       )
													else:
																		__SCREAMING_SNAKE_CASE					:							Optional[int]			   = f"""Node with label {label} already exists"""
																		raise Exception(lowercase       )

								return node




			def 			_snake_case   (      self					,      lowercase       )			->						Node:


								'''simple docstring'''






								return self._search(self.root					,      lowercase       )




			def 			_snake_case   (      self					,      lowercase					,      lowercase       )			->						Node:


								'''simple docstring'''






								if node is None:
													__SCREAMING_SNAKE_CASE					:							Union[str, Any]			   = f"""Node with label {label} does not exist"""
													raise Exception(lowercase       )
								else:
													if label < node.label:
																		__SCREAMING_SNAKE_CASE					:							Dict			   = self._search(node.left					,      lowercase       )
													elif label > node.label:
																		__SCREAMING_SNAKE_CASE					:							List[str]			   = self._search(node.right					,      lowercase       )

								return node




			def 			_snake_case   (      self					,      lowercase       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Any			   = self.search(lowercase       )
								if node.right and node.left:
													__SCREAMING_SNAKE_CASE					:							Dict			   = self._get_lowest_node(node.right       )
													__SCREAMING_SNAKE_CASE					:							Tuple			   = node.left
													__SCREAMING_SNAKE_CASE					:							Union[str, Any]			   = node.right
													__SCREAMING_SNAKE_CASE					:							Optional[int]			   = lowest_node
													if node.right:
																		__SCREAMING_SNAKE_CASE					:							Any			   = lowest_node
													self._reassign_nodes(lowercase					,      lowercase       )
								elif not node.right and node.left:
													self._reassign_nodes(lowercase					,      node.left       )
								elif node.right and not node.left:
													self._reassign_nodes(lowercase					,      node.right       )
								else:
													self._reassign_nodes(lowercase					,      lowercase       )




			def 			_snake_case   (      self					,      lowercase					,      lowercase       )			->						None:


								'''simple docstring'''






								if new_children:
													__SCREAMING_SNAKE_CASE					:							str			   = node.parent

								if node.parent:
													if node.parent.right == node:
																		__SCREAMING_SNAKE_CASE					:							Tuple			   = new_children
													else:
																		__SCREAMING_SNAKE_CASE					:							Optional[Any]			   = new_children
								else:
													__SCREAMING_SNAKE_CASE					:							Tuple			   = new_children




			def 			_snake_case   (      self					,      lowercase       )			->						Node:


								'''simple docstring'''






								if node.left:
													__SCREAMING_SNAKE_CASE					:							Optional[Any]			   = self._get_lowest_node(node.left       )
								else:
													__SCREAMING_SNAKE_CASE					:							Union[str, Any]			   = node
													self._reassign_nodes(lowercase					,      node.right       )

								return lowest_node




			def 			_snake_case   (      self					,      lowercase       )			->						bool:


								'''simple docstring'''






								try:
													self.search(lowercase       )
													return True
								except Exception:
													return False




			def 			_snake_case   (      self       )			->						int:


								'''simple docstring'''






								if self.root is None:
													raise Exception('''Binary search tree is empty'''       )

								__SCREAMING_SNAKE_CASE					:							List[Any]			   = self.root
								while node.right is not None:
													__SCREAMING_SNAKE_CASE					:							Any			   = node.right

								return node.label




			def 			_snake_case   (      self       )			->						int:


								'''simple docstring'''






								if self.root is None:
													raise Exception('''Binary search tree is empty'''       )

								__SCREAMING_SNAKE_CASE					:							Any			   = self.root
								while node.left is not None:
													__SCREAMING_SNAKE_CASE					:							Optional[int]			   = node.left

								return node.label




			def 			_snake_case   (      self       )			->						Iterator[Node]:


								'''simple docstring'''






								return self._inorder_traversal(self.root       )




			def 			_snake_case   (      self					,      lowercase       )			->						Iterator[Node]:


								'''simple docstring'''






								if node is not None:
													yield from self._inorder_traversal(node.left       )
													yield node
													yield from self._inorder_traversal(node.right       )




			def 			_snake_case   (      self       )			->						Iterator[Node]:


								'''simple docstring'''






								return self._preorder_traversal(self.root       )




			def 			_snake_case   (      self					,      lowercase       )			->						Iterator[Node]:


								'''simple docstring'''






								if node is not None:
													yield node
													yield from self._preorder_traversal(node.left       )
													yield from self._preorder_traversal(node.right       )






class      SCREAMING_SNAKE_CASE_	( unittest.TestCase		):




			@staticmethod
			def 			_snake_case   (      )			->						BinarySearchTree:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							int			   = BinarySearchTree()
								t.put(8       )
								t.put(3       )
								t.put(6       )
								t.put(1       )
								t.put(1_0       )
								t.put(1_4       )
								t.put(1_3       )
								t.put(4       )
								t.put(7       )
								t.put(5       )

								return t




			def 			_snake_case   (      self       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Optional[int]			   = BinarySearchTree()
								assert t.is_empty()

								t.put(8       )
								assert t.root is not None
								assert t.root.parent is None
								assert t.root.label == 8

								t.put(1_0       )
								assert t.root.right is not None
								assert t.root.right.parent == t.root
								assert t.root.right.label == 1_0

								t.put(3       )
								assert t.root.left is not None
								assert t.root.left.parent == t.root
								assert t.root.left.label == 3

								t.put(6       )
								assert t.root.left.right is not None
								assert t.root.left.right.parent == t.root.left
								assert t.root.left.right.label == 6

								t.put(1       )
								assert t.root.left.left is not None
								assert t.root.left.left.parent == t.root.left
								assert t.root.left.left.label == 1

								with self.assertRaises(lowercase       ):  # noqa: B017
													t.put(1       )




			def 			_snake_case   (      self       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							List[str]			   = self._get_binary_search_tree()

								__SCREAMING_SNAKE_CASE					:							Optional[int]			   = t.search(6       )
								assert node.label == 6

								__SCREAMING_SNAKE_CASE					:							Optional[int]			   = t.search(1_3       )
								assert node.label == 1_3

								with self.assertRaises(lowercase       ):  # noqa: B017
													t.search(2       )




			def 			_snake_case   (      self       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							str			   = self._get_binary_search_tree()

								t.remove(1_3       )
								assert t.root is not None
								assert t.root.right is not None
								assert t.root.right.right is not None
								assert t.root.right.right.right is None
								assert t.root.right.right.left is None

								t.remove(7       )
								assert t.root.left is not None
								assert t.root.left.right is not None
								assert t.root.left.right.left is not None
								assert t.root.left.right.right is None
								assert t.root.left.right.left.label == 4

								t.remove(6       )
								assert t.root.left.left is not None
								assert t.root.left.right.right is not None
								assert t.root.left.left.label == 1
								assert t.root.left.right.label == 4
								assert t.root.left.right.right.label == 5
								assert t.root.left.right.left is None
								assert t.root.left.left.parent == t.root.left
								assert t.root.left.right.parent == t.root.left

								t.remove(3       )
								assert t.root is not None
								assert t.root.left.label == 4
								assert t.root.left.right.label == 5
								assert t.root.left.left.label == 1
								assert t.root.left.parent == t.root
								assert t.root.left.left.parent == t.root.left
								assert t.root.left.right.parent == t.root.left

								t.remove(4       )
								assert t.root.left is not None
								assert t.root.left.left is not None
								assert t.root.left.label == 5
								assert t.root.left.right is None
								assert t.root.left.left.label == 1
								assert t.root.left.parent == t.root
								assert t.root.left.left.parent == t.root.left




			def 			_snake_case   (      self       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Dict			   = self._get_binary_search_tree()

								t.remove(3       )
								assert t.root is not None
								assert t.root.left is not None
								assert t.root.left.left is not None
								assert t.root.left.right is not None
								assert t.root.left.right.left is not None
								assert t.root.left.right.right is not None
								assert t.root.left.label == 4
								assert t.root.left.right.label == 6
								assert t.root.left.left.label == 1
								assert t.root.left.right.right.label == 7
								assert t.root.left.right.left.label == 5
								assert t.root.left.parent == t.root
								assert t.root.left.right.parent == t.root.left
								assert t.root.left.left.parent == t.root.left
								assert t.root.left.right.left.parent == t.root.left.right




			def 			_snake_case   (      self       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Optional[int]			   = self._get_binary_search_tree()
								t.empty()
								assert t.root is None




			def 			_snake_case   (      self       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Optional[Any]			   = self._get_binary_search_tree()
								assert not t.is_empty()

								t.empty()
								assert t.is_empty()




			def 			_snake_case   (      self       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Optional[Any]			   = self._get_binary_search_tree()

								assert t.exists(6       )
								assert not t.exists(-1       )




			def 			_snake_case   (      self       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Any			   = self._get_binary_search_tree()

								assert t.get_max_label() == 1_4

								t.empty()
								with self.assertRaises(lowercase       ):  # noqa: B017
													t.get_max_label()




			def 			_snake_case   (      self       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							int			   = self._get_binary_search_tree()

								assert t.get_min_label() == 1

								t.empty()
								with self.assertRaises(lowercase       ):  # noqa: B017
													t.get_min_label()




			def 			_snake_case   (      self       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Union[str, Any]			   = self._get_binary_search_tree()

								__SCREAMING_SNAKE_CASE					:							Dict			   = [i.label for i in t.inorder_traversal()]
								assert inorder_traversal_nodes == [1, 3, 4, 5, 6, 7, 8, 1_0, 1_3, 1_4]




			def 			_snake_case   (      self       )			->						None:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							int			   = self._get_binary_search_tree()

								__SCREAMING_SNAKE_CASE					:							Tuple			   = [i.label for i in t.preorder_traversal()]
								assert preorder_traversal_nodes == [8, 3, 1, 6, 4, 5, 7, 1_0, 1_4, 1_3]




def A_					(				)     ->  None:
					__SCREAMING_SNAKE_CASE					:							Tuple			   = BinarySearchTree()
					t.put(8       )
					t.put(3       )
					t.put(6       )
					t.put(1       )
					t.put(10       )
					t.put(14       )
					t.put(13       )
					t.put(4       )
					t.put(7       )
					t.put(5       )

					print(
					    '''
            8
           / \\
          3   10
         / \\    \\
        1   6    14
           / \\   /
          4   7 13
           \\
            5
        '''       )

					print('''Label 6 exists:'''	,   t.exists(6       )       )
					print('''Label 13 exists:'''	,   t.exists(13       )       )
					print('''Label -1 exists:'''	,   t.exists(-1       )       )
					print('''Label 12 exists:'''	,   t.exists(12       )       )

					# Prints all the elements of the list in inorder traversal
					__SCREAMING_SNAKE_CASE					:							str			   = [i.label for i in t.inorder_traversal()]
					print('''Inorder traversal:'''	,   __SCREAMING_SNAKE_CASE       )

					# Prints all the elements of the list in preorder traversal
					__SCREAMING_SNAKE_CASE					:							Optional[Any]			   = [i.label for i in t.preorder_traversal()]
					print('''Preorder traversal:'''	,   __SCREAMING_SNAKE_CASE       )

					print('''Max. label:'''	,   t.get_max_label()       )
					print('''Min. label:'''	,   t.get_min_label()       )

					# Delete elements
					print('''\nDeleting elements 13, 10, 8, 3, 6, 14'''       )
					print(
					    '''
          4
         / \\
        1   7
             \\
              5
        '''       )
					t.remove(13       )
					t.remove(10       )
					t.remove(8       )
					t.remove(3       )
					t.remove(6       )
					t.remove(14       )

					# Prints all the elements of the list in inorder traversal after delete
					__SCREAMING_SNAKE_CASE					:							Optional[Any]			   = [i.label for i in t.inorder_traversal()]
					print('''Inorder traversal after delete:'''	,   __SCREAMING_SNAKE_CASE       )

					# Prints all the elements of the list in preorder traversal after delete
					__SCREAMING_SNAKE_CASE					:							str			   = [i.label for i in t.preorder_traversal()]
					print('''Preorder traversal after delete:'''	,   __SCREAMING_SNAKE_CASE       )

					print('''Max. label:'''	,   t.get_max_label()       )
					print('''Min. label:'''	,   t.get_min_label()       )


if __name__ == "__main__":
						binary_search_tree_example()






'''simple docstring'''






from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


_A      =     logging.get_logger(__name__)

_A      =     {
    """facebook/m2m100_418M""": """https://huggingface.co/facebook/m2m100_418M/resolve/main/config.json""",
    # See all M2M100 models at https://huggingface.co/models?filter=m2m_100
}






class      SCREAMING_SNAKE_CASE_	( snake_case		):
			__a					:      Any					=  '''m2m_100'''
			__a					:      List[str]					=  ['''past_key_values''']
			__a					:      str					=  {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}




			def __init__(      self					,      lowercase=1_2_8_1_1_2					,      lowercase=1_0_2_4					,      lowercase=1_2					,      lowercase=4_0_9_6					,      lowercase=1_6					,      lowercase=1_2					,      lowercase=4_0_9_6					,      lowercase=1_6					,      lowercase=0.0_5					,      lowercase=0.0_5					,      lowercase=True					,      lowercase=True					,      lowercase="relu"					,      lowercase=1_0_2_4					,      lowercase=0.1					,      lowercase=0.1					,      lowercase=0.0					,      lowercase=0.0_2					,      lowercase=2					,      lowercase=True					,      lowercase=1					,      lowercase=0					,      lowercase=2					,      **lowercase					,      )			->						Optional[int]:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							int			   = vocab_size
								__SCREAMING_SNAKE_CASE					:							Optional[Any]			   = max_position_embeddings
								__SCREAMING_SNAKE_CASE					:							int			   = d_model
								__SCREAMING_SNAKE_CASE					:							List[Any]			   = encoder_ffn_dim
								__SCREAMING_SNAKE_CASE					:							int			   = encoder_layers
								__SCREAMING_SNAKE_CASE					:							Any			   = encoder_attention_heads
								__SCREAMING_SNAKE_CASE					:							List[str]			   = decoder_ffn_dim
								__SCREAMING_SNAKE_CASE					:							Any			   = decoder_layers
								__SCREAMING_SNAKE_CASE					:							str			   = decoder_attention_heads
								__SCREAMING_SNAKE_CASE					:							List[Any]			   = dropout
								__SCREAMING_SNAKE_CASE					:							Tuple			   = attention_dropout
								__SCREAMING_SNAKE_CASE					:							int			   = activation_dropout
								__SCREAMING_SNAKE_CASE					:							Union[str, Any]			   = activation_function
								__SCREAMING_SNAKE_CASE					:							Union[str, Any]			   = init_std
								__SCREAMING_SNAKE_CASE					:							int			   = encoder_layerdrop
								__SCREAMING_SNAKE_CASE					:							Dict			   = decoder_layerdrop
								__SCREAMING_SNAKE_CASE					:							Optional[Any]			   = use_cache
								__SCREAMING_SNAKE_CASE					:							Optional[int]			   = encoder_layers
								__SCREAMING_SNAKE_CASE					:							List[str]			   = scale_embedding  # scale factor will be sqrt(d_model) if True

								super().__init__(
								    pad_token_id=lowercase					,      bos_token_id=lowercase					,      eos_token_id=lowercase					,      is_encoder_decoder=lowercase					,      decoder_start_token_id=lowercase					,      **lowercase					,      )






class      SCREAMING_SNAKE_CASE_	( snake_case		):




			@property
			def 			_snake_case   (      self       )			->						Mapping[str, Mapping[int, str]]:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Any			   = OrderedDict(
								    [
								        ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
								        ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
								    ]       )

								if self.use_past:
													__SCREAMING_SNAKE_CASE					:							str			   = {0: '''batch'''}
													__SCREAMING_SNAKE_CASE					:							Any			   = {0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
								else:
													__SCREAMING_SNAKE_CASE					:							Tuple			   = {0: '''batch''', 1: '''decoder_sequence'''}
													__SCREAMING_SNAKE_CASE					:							str			   = {0: '''batch''', 1: '''decoder_sequence'''}

								if self.use_past:
													self.fill_with_past_key_values_(lowercase					,      direction='''inputs'''       )
								return common_inputs




			def 			_snake_case   (      self					,      lowercase					,      lowercase = -1					,      lowercase = -1					,      lowercase = False					,      lowercase = None					,      )			->						Mapping[str, Any]:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Dict			   = compute_effective_axis_dimension(
								    lowercase					,      fixed_dimension=OnnxConfig.default_fixed_batch					,      num_token_to_add=0       )

								# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
								__SCREAMING_SNAKE_CASE					:							Union[str, Any]			   = tokenizer.num_special_tokens_to_add(lowercase       )
								__SCREAMING_SNAKE_CASE					:							Optional[int]			   = compute_effective_axis_dimension(
								    lowercase					,      fixed_dimension=OnnxConfig.default_fixed_sequence					,      num_token_to_add=lowercase       )

								# Generate dummy inputs according to compute batch and sequence
								__SCREAMING_SNAKE_CASE					:							List[Any]			   = [''' '''.join([tokenizer.unk_token]       ) * seq_length] * batch_size
								__SCREAMING_SNAKE_CASE					:							Dict			   = dict(tokenizer(lowercase					,      return_tensors=lowercase       )       )
								return common_inputs




			def 			_snake_case   (      self					,      lowercase					,      lowercase = -1					,      lowercase = -1					,      lowercase = False					,      lowercase = None					,      )			->						Mapping[str, Any]:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Dict			   = self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
								    lowercase					,      lowercase					,      lowercase					,      lowercase					,      lowercase       )

								# Generate decoder inputs
								__SCREAMING_SNAKE_CASE					:							str			   = seq_length if not self.use_past else 1
								__SCREAMING_SNAKE_CASE					:							List[str]			   = self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
								    lowercase					,      lowercase					,      lowercase					,      lowercase					,      lowercase       )
								__SCREAMING_SNAKE_CASE					:							Any			   = {f"""decoder_{name}""": tensor for name, tensor in decoder_inputs.items()}
								__SCREAMING_SNAKE_CASE					:							List[str]			   = dict(**lowercase					,      **lowercase       )

								if self.use_past:
													if not is_torch_available():
																		raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''       )
													else:
																		import torch
													__SCREAMING_SNAKE_CASE   ,   __SCREAMING_SNAKE_CASE					:							Tuple			   = common_inputs['''input_ids'''].shape
													__SCREAMING_SNAKE_CASE					:							Union[str, Any]			   = common_inputs['''decoder_input_ids'''].shape[1]
													__SCREAMING_SNAKE_CASE   ,   __SCREAMING_SNAKE_CASE					:							Union[str, Any]			   = self.num_attention_heads
													__SCREAMING_SNAKE_CASE					:							Union[str, Any]			   = (
													    batch,
													    num_encoder_attention_heads,
													    encoder_seq_length,
													    self._config.hidden_size // num_encoder_attention_heads,
													)
													__SCREAMING_SNAKE_CASE					:							List[Any]			   = decoder_seq_length + 3
													__SCREAMING_SNAKE_CASE					:							Union[str, Any]			   = (
													    batch,
													    num_decoder_attention_heads,
													    decoder_past_length,
													    self._config.hidden_size // num_decoder_attention_heads,
													)

													__SCREAMING_SNAKE_CASE					:							List[Any]			   = torch.cat(
													    [common_inputs['''decoder_attention_mask'''], torch.ones(lowercase					,      lowercase       )]					,      dim=1       )

													__SCREAMING_SNAKE_CASE					:							Any			   = []
													# If the number of encoder and decoder layers are present in the model configuration, both are considered
													__SCREAMING_SNAKE_CASE   ,   __SCREAMING_SNAKE_CASE					:							Union[str, Any]			   = self.num_layers
													__SCREAMING_SNAKE_CASE					:							List[str]			   = min(lowercase					,      lowercase       )
													__SCREAMING_SNAKE_CASE					:							str			   = max(lowercase					,      lowercase       ) - min_num_layers
													__SCREAMING_SNAKE_CASE					:							Tuple			   = '''encoder''' if num_encoder_layers > num_decoder_layers else '''decoder'''

													for _ in range(lowercase       ):
																		common_inputs["past_key_values"].append(
																		    (
																		        torch.zeros(lowercase       ),
																		        torch.zeros(lowercase       ),
																		        torch.zeros(lowercase       ),
																		        torch.zeros(lowercase       ),
																		    )       )
													# TODO: test this.
													__SCREAMING_SNAKE_CASE					:							Optional[int]			   = encoder_shape if remaining_side_name == '''encoder''' else decoder_shape
													for _ in range(lowercase					,      lowercase       ):
																		common_inputs["past_key_values"].append((torch.zeros(lowercase       ), torch.zeros(lowercase       ))       )
								return common_inputs

			__a					:      Optional[int]					=  _generate_dummy_inputs_for_default_and_seqaseq_lm


