text: from functools import lru_cache
  from functools import wraps, partial
  from typing import Mapping, Optional, Any, Type, TypeVar, Union, Callable, Tuple
  
  from graphviz import Digraph
  from hbutils.reflection import dynamic_call, raising
  
  from ..func import method_treelize, MISSING_NOT_ALLOW, func_treelize
  from ..tree import TreeValue, jsonify, clone, typetrans, mapping, mask, filter_, reduce_, union, graphics
  from ..tree import rise as rise_func
  from ..tree import subside as subside_func
  
  _BASE_GENERATION_CONFIG = {}
  
  
  def general_tree_value(base: Optional[Mapping[str, Any]] = None,
                         methods: Optional[Mapping[str, Any]] = None):
      """
      Overview:
          Get general tree value class.
  
      Arguments:
          - base (:obj:`Optional[Mapping[str, Any]]`): Base configuration of `func_treelize`.
          - methods (:obj:`Optional[Mapping[str, Any]]`): Method configurations of `func_treelize`.
  
      Returns:
          - clazz (:obj:`Type[TreeValue]`): General tree value class.
      """
      base = base or {}
      methods = methods or {}
  
      def _dynamic_suffix_dec(func, f):
          return wraps(func)(dynamic_call(f))
  
      @lru_cache()
      def _get_decorator(name, treelize: bool, ext_cfg: Optional[tuple] = None):
          _item = methods.get(name, None)
  
          if treelize and isinstance(_item or {}, dict):
              _config = _BASE_GENERATION_CONFIG.copy()
              _config.update(base)
              _config.update(_item or {})
              _config.update(dict(ext_cfg or ()))
              return lambda func: method_treelize(**_config)(func)
          elif isinstance(_item, BaseException) or (isinstance(_item, type) and issubclass(_item, BaseException)):
              return lambda func: _dynamic_suffix_dec(func, raising(_item))
          elif hasattr(_item, '__call__'):
              return lambda func: _dynamic_suffix_dec(func, _item)
          elif name in methods.keys():
              return lambda func: _dynamic_suffix_dec(func, lambda: methods[name])
          else:
              return lambda func: func
  
      def _decorate(func, treelize: bool, ext_cfg: Optional[dict] = None):
          return _get_decorator(func.__name__, treelize, tuple(sorted((ext_cfg or {}).items())))(func)
  
      _decorate_treelize = partial(_decorate, treelize=True)
      _decorate_method = partial(_decorate, treelize=False)
      _decorate_and_replace = partial(_decorate, treelize=True, ext_cfg=dict(self_copy=True))
  
      _TreeValue = TypeVar("_TreeValue", bound=TreeValue)
  
      # noinspection PyUnresolvedReferences,PyMethodFirstArgAssignment
      class _GeneralTreeValue(TreeValue):
          @method_treelize()
          def _attr_extern(self, key):
              """
              Overview:
                  External protected function for support the unfounded attributes. \
                  In `FastTreeValue` it is extended to support the access to values' attribute.
  
              Arguments:
                  - key (:obj:`str`): Attribute name.
  
              Returns:
                  - return (:obj:): TreeValue of the values' attribute.
  
              Example:
                  >>> class Container:
                  >>>     def __init__(self, value):
                  >>>         self.__value = value
                  >>>
                  >>>     @property
                  >>>     def value(self):
                  >>>         return self.__value
                  >>>
                  >>>     def append(self, v):
                  >>>         return self.__value + v
                  >>>
                  >>> t = FastTreeValue({'a': Container(1), 'b': Container(2)})
                  >>> t.value   # FastTreeValue({'a': 1, 'b': 2})
                  >>> t.append  # FastTreeValue({'a': <method 'append' of Container(1)>, 'b': <method 'append' of Container(2)>})
              """
              return getattr(self, key)
  
          @_decorate_method
          def json(self):
              """
              Overview:
                  Dump current `TreeValue` object to json data.
  
              Returns:
                  - json (:obj:`dict`): Dumped json data.
  
              Example:
                  >>> t = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t.json()  # {'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}}
              """
              return jsonify(self)
  
          @_decorate_method
          def clone(self, copy_value: Union[None, bool, Callable, Any] = None):
              """
              Overview:
                  Create a fully clone of the current tree.
  
              Returns:
                  - tree (:obj:`_TreeValue`): Cloned tree value object.
                  - copy_value (:obj:`Union[None, bool, Callable, Any]`): Deep copy value or not, \
                      default is `None` which means do not deep copy the values. \
                      If deep copy is required, just set it to `True`.
  
              Example:
                  >>> t = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t.x.clone()  # FastTreeValue({'c': 3, 'd': 4})
              """
              return clone(self, copy_value)
  
          @_decorate_method
          def type(self, clazz: Type[_TreeValue]) -> _TreeValue:
              """
              Overview:
                  Transform tree value object to another tree value type. \
                  Attention that in this function, no copy will be made, \
                  the original tree value and the transformed tree value are using the same space area.
  
              Arguments:
                  - return_type (:obj:`Type[_TreeValue]`): Target tree value type
  
              Returns:
                  - tree (:obj:`_TreeValue`): Transformed tree value object.
  
              Example:
                  >>> t = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t.type(TreeValue)  # TreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
              """
              return typetrans(self, clazz)
  
          @_decorate_method
          def map(self, mapper, delayed=False):
              """
              Overview:
                  Do mapping on every value in this tree.
  
              Arguments:
                  - func (:obj:): Function for mapping
                  - delayed (:obj:`bool`): Enable delayed mode for this mapping.
  
              Returns:
                  - tree (:obj:`_TreeValue`): Mapped tree value object.
  
              Example:
                  >>> t = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t.map(lambda x: x + 2)  # FastTreeValue({'a': 3, 'b': 4, 'x': {'c': 5, 'd': 6}})
                  >>> t.map(lambda: 1)        # FastTreeValue({'a': 1, 'b': 1, 'x': {'c': 1, 'd': 1}})
                  >>> t.map(lambda x, p: p)   # FastTreeValue({'a': ('a',), 'b': ('b',), 'x': {'c': ('x', 'c'), 'd': ('x', 'd')}})
              """
              return mapping(self, mapper, delayed)
  
          @_decorate_method
          def mask(self, mask_: TreeValue, remove_empty: bool = True):
              """
              Overview:
                  Filter the element in the tree with a mask
  
              Arguments:
                  - `mask_` (:obj:`TreeValue`): Tree value mask object
                  - `remove_empty` (:obj:`bool`): Remove empty tree node automatically, default is `True`.
  
              Returns:
                  - tree (:obj:`_TreeValue`): Filtered tree value object.
  
              Example:
                  >>> t = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t.mask(TreeValue({'a': True, 'b': False, 'x': False}))                    # FastTreeValue({'a': 1})
                  >>> t.mask(TreeValue({'a': True, 'b': False, 'x': {'c': True, 'd': False}}))  # FastTreeValue({'a': 1, 'x': {'c': 3}})
              """
              return mask(self, mask_, remove_empty)
  
          @_decorate_method
          def filter(self, func, remove_empty: bool = True):
              """
              Overview:
                  Filter the element in the tree with a predict function.
  
              Arguments:
                  - func (:obj:): Function for filtering
                  - remove_empty (:obj:`bool`): Remove empty tree node automatically, default is `True`.
  
              Returns:
                  - tree (:obj:`_TreeValue`): Filtered tree value object.
  
              Example:
                  >>> t = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t.filter(lambda x: x < 3)                  # FastTreeValue({'a': 1, 'b': 2})
                  >>> t.filter(lambda x: x < 3, False)           # FastTreeValue({'a': 1, 'b': 2, 'x': {}})
                  >>> t.filter(lambda x: x % 2 == 1)             # FastTreeValue({'a': 1, 'x': {'c': 3}})
                  >>> t.filter(lambda x, p: p[0] in {'b', 'x'})  # FastTreeValue({'b': 2, 'x': {'c': 3, 'd': 4}})
              """
              return filter_(self, func, remove_empty)
  
          @_decorate_method
          def reduce(self, func):
              """
              Overview
                  Reduce the tree to value.
  
              Arguments:
                  - func (:obj:): Function for reducing
  
              Returns:
                  - result (:obj:): Reduce result
  
              Examples:
                  >>> from functools import reduce
                  >>>
                  >>> t = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t.reduce(lambda **kwargs: sum(kwargs.values()))  # 10, 1 + 2 + (3 + 4)
                  >>> t.reduce(lambda **kwargs: reduce(lambda x, y: x * y, list(kwargs.values())))  # 24, 1 * 2 * (3 * 4)
              """
              return reduce_(self, func)
  
          @_decorate_method
          def rise(self, dict_: bool = True, list_: bool = True, tuple_: bool = True, template=None):
              """
              Overview:
                  Make the structure (dict, list, tuple) in value rise up to the top, above the tree value.
  
              Arguments:
                  - `dict_` (:obj:`bool`): Enable dict rise, default is `True`.
                  - `list_` (:obj:`bool`): Enable list rise, default is `True`.
                  - `tuple_` (:obj:`bool`): Enable list rise, default is `True`.
                  - template (:obj:): Rising template, default is `None`, which means auto detect.
  
              Returns:
                  - risen (:obj:): Risen value.
  
              Example:
                  >>> t = FastTreeValue({'x': raw({'a': [1, 2], 'b': [2, 3]}), 'y': raw({'a': [5, 6, 7], 'b': [7, 8]})})
                  >>> dt = t.rise()
                  >>> # dt will be {'a': <FastTreeValue 1>, 'b': [<FastTreeValue 2>, <FastTreeValue 3>]}
                  >>> # FastTreeValue 1 will be FastTreeValue({'x': [1, 2], 'y': [5, 6, 7]})
                  >>> # FastTreeValue 2 will be FastTreeValue({'x': 2, 'y': 7})
                  >>> # FastTreeValue 3 will be FastTreeValue({'x': 3, 'y': 8})
                  >>>
                  >>> t2 = FastTreeValue({'x': raw({'a': [1, 2], 'b': [2, 3]}), 'y': raw({'a': [5, 6], 'b': [7, 8]})})
                  >>> dt2 = t2.rise()
                  >>> # dt2 will be {'a': [<FastTreeValue 1>, <FastTreeValue 2>], 'b': [<FastTreeValue 3>, <FastTreeValue 4>]}
                  >>> # FastTreeValue 1 will be FastTreeValue({'x': 1, 'y': 5})
                  >>> # FastTreeValue 2 will be FastTreeValue({'x': 2, 'y': 6})
                  >>> # FastTreeValue 3 will be FastTreeValue({'x': 2, 'y': 7})
                  >>> # FastTreeValue 4 will be FastTreeValue({'x': 3, 'y': 8})
                  >>>
                  >>> dt3 = t2.rise(template={'a': None, 'b': None})
                  >>> # dt3 will be {'a': <FastTreeValue 1>, 'b': <FastTreeValue 2>}
                  >>> # FastTreeValue 1 will be FastTreeValue({'x': [1, 2], 'y': [5, 6]})
                  >>> # FastTreeValue 2 will be FastTreeValue({'x': [2, 3], 'y': [7, 8]})
              """
              return rise_func(self, dict_, list_, tuple_, template)
  
          @_decorate_method
          def graph(self, root: Optional[str] = None, title: Optional[str] = None,
                    cfg: Optional[dict] = None,
                    dup_value: Union[bool, Callable, type, Tuple[Type, ...]] = False,
                    repr_gen: Optional[Callable] = None,
                    node_cfg_gen: Optional[Callable] = None,
                    edge_cfg_gen: Optional[Callable] = None) -> Digraph:
              """
              Overview:
                  Draw graph of this tree value.
  
              Args:
                  - root (:obj:`Optional[str]`): Root name of the graph, default is ``None``, \
                      this name will be automatically generated.
                  - title (:obj:`Optional[str]`): Title of the graph, default is ``None``, \
                      this title will be automatically generated from ``root`` argument.
                  - cfg (:obj:`Optional[dict]`): Configuration of the graph.
                  - dup_value (:obj:`Union[bool, Callable, type, Tuple[Type, ...]]`): Value duplicator, \
                      set `True` to make value with same id use the same node in graph, \
                      you can also define your own node id algorithm by this argument. \
                      Default is `False` which means do not use value duplicator.
                  - repr_gen (:obj:`Optional[Callable]`): Representation format generator, \
                      default is `None` which means using `repr` function.
                  - node_cfg_gen (:obj:`Optional[Callable]`): Node configuration generator, \
                      default is `None` which means no configuration.
                  - edge_cfg_gen (:obj:`Optional[Callable]`): Edge configuration generator, \
                      default is `None` which means no configuration.
  
              Returns:
                  - graph (:obj:`Digraph`): Generated graph of tree values.
              """
              root = root or ('<%s #%x>' % (type(self).__name__, id(self._detach())))
              title = title or ('Graph of tree %s.' % (root,))
              return graphics(
                  (self, root), title=title, cfg=cfg, dup_value=dup_value,
                  repr_gen=repr_gen, node_cfg_gen=node_cfg_gen, edge_cfg_gen=edge_cfg_gen,
              )
  
          @classmethod
          @_decorate_method
          def func(cls, mode: str = 'strict', inherit: bool = True,
                   missing: Union[Any, Callable] = MISSING_NOT_ALLOW, delayed: bool = False,
                   subside: Union[Mapping, bool, None] = None, rise: Union[Mapping, bool, None] = None):
              """
              Overview:
                  Wrap a common function to tree-supported function based on this type.
  
              Arguments:
                  - mode (:obj:`str`): Mode of the wrapping, default is `strict`.
                  - inherit (:obj:`bool`): Allow inherit in wrapped function, default is `True`.
                  - missing (:obj:`Union[Any, Callable]`): Missing value or lambda generator of when missing, \
                      default is `MISSING_NOT_ALLOW`, which means raise `KeyError` when missing detected.
                  - delayed (:obj:`bool`): Enable delayed mode or not, the calculation will be delayed when enabled, \
                      default is ``False``, which means to all the calculation at once.
                  - subside (:obj:`Union[Mapping, bool, None]`): Subside enabled to function's arguments or not, \
                      and subside configuration, default is `None` which means do not use subside. \
                      When subside is `True`, it will use all the default arguments in `subside` function.
                  - rise (:obj:`Union[Mapping, bool, None]`): Rise enabled to function's return value or not, \
                      and rise configuration, default is `None` which means do not use rise. \
                      When rise is `True`, it will use all the default arguments in `rise` function. \
                      (Not recommend to use auto mode when your return structure is not so strict.)
  
              Returns:
                  - decorator (:obj:`Callable`): Wrapper for tree-supported function.
  
              Example:
                  >>> from treevalue import FastTreeValue
                  >>>
                  >>> @FastTreeValue.func()
                  >>> def ssum(a, b):
                  >>>     return a + b  # the a and b will be integers, not TreeValue
                  >>>
                  >>> t1 = TreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = TreeValue({'a': 11, 'b': 22, 'x': {'c': 33, 'd': 5}})
                  >>> ssum(1, 2)    # 3
                  >>> ssum(t1, t2)  # FastTreeValue({'a': 12, 'b': 24, 'x': {'c': 36, 'd': 9}})
              """
              return func_treelize(mode, cls, inherit, missing, delayed, subside, rise)
  
          @classmethod
          @_decorate_method
          def union(cls, *trees, return_type=None, **kwargs):
              """
              Overview:
                  Union tree values together.
  
              Arguments:
                  - trees (:obj:`_TreeValue`): Tree value objects.
                  - mode (:obj:): Mode of the wrapping, default is `strict`.
                  - return_type (:obj:`Optional[Type[_ClassType]]`): Return type of the wrapped function, default is `TreeValue`.
                  - inherit (:obj:`bool`): Allow inherit in wrapped function, default is `True`.
                  - missing (:obj:): Missing value or lambda generator of when missing, default is `MISSING_NOT_ALLOW`, which \
                      means raise `KeyError` when missing detected.
  
              Returns:
                  - result (:obj:`TreeValue`): Unionised tree value.
  
              Example:
                  >>> t = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> tx = t.map(lambda v: v % 2 == 1)
                  >>> FastTreeValue.union(t, tx)  # FastTreeValue({'a': (1, True), 'b': (2, False), 'x': {'c': (3, True), 'd': (4, False)}})
              """
              return union(*trees, return_type=return_type or cls, **kwargs)
  
          @classmethod
          @_decorate_method
          def subside(cls, value, dict_: bool = True, list_: bool = True, tuple_: bool = True,
                      return_type: Optional[Type[_TreeValue]] = None, **kwargs):
              """
              Overview:
                  Drift down the structures (list, tuple, dict) down to the tree's value.
  
              Arguments:
                  - value (:obj:): Original value object, may be nested dict, list or tuple.
                  - `dict_` (:obj:`bool`): Enable dict subside, default is `True`.
                  - `list_` (:obj:`bool`): Enable list subside, default is `True`.
                  - `tuple_` (:obj:`bool`): Enable list subside, default is `True`.
                  - mode (:obj:): Mode of the wrapping, default is `strict`.
                  - return_type (:obj:`Optional[Type[_ClassType]]`): Return type of the wrapped function, \
                      will be auto detected when there is exactly one tree value type in this original value, \
                      otherwise the default will be `TreeValue`.
                  - inherit (:obj:`bool`): Allow inherit in wrapped function, default is `True`.
                  - missing (:obj:): Missing value or lambda generator of when missing, default is `MISSING_NOT_ALLOW`, which \
                      means raise `KeyError` when missing detected.
  
              Returns:
                  - return (:obj:`_TreeValue`): Subsided tree value.
  
              Example:
                  >>> data = {
                  >>>     'a': TreeValue({'a': 1, 'b': 2}),
                  >>>     'x': {
                  >>>         'c': TreeValue({'a': 3, 'b': 4}),
                  >>>         'd': [
                  >>>             TreeValue({'a': 5, 'b': 6}),
                  >>>             TreeValue({'a': 7, 'b': 8}),
                  >>>         ]
                  >>>     },
                  >>>     'k': '233'
                  >>> }
                  >>>
                  >>> tree = FastTreeValue.subside(data)
                  >>> # tree should be --> FastTreeValue({
                  >>> #    'a': raw({'a': 1, 'k': '233', 'x': {'c': 3, 'd': [5, 7]}}),
                  >>> #    'b': raw({'a': 2, 'k': '233', 'x': {'c': 4, 'd': [6, 8]}}),
                  >>> #}), all structures above the tree values are subsided to the bottom of the tree.
              """
              return subside_func(value, dict_, list_, tuple_,
                                  return_type=return_type or cls, **kwargs)
  
          @classmethod
          @_decorate_method
          def graphics(cls, *trees, title: Optional[str] = None, cfg: Optional[dict] = None,
                       dup_value: Union[bool, Callable, type, Tuple[Type, ...]] = False,
                       repr_gen: Optional[Callable] = None,
                       node_cfg_gen: Optional[Callable] = None,
                       edge_cfg_gen: Optional[Callable] = None) -> Digraph:
              """
              Overview:
                  Draw graph by tree values.
                  Multiple tree values is supported.
  
              Args:
                  - trees: Given tree values, tuples of `Tuple[TreeValue, str]` or tree values are both accepted.
                  - title (:obj:`Optional[str]`): Title of the graph.
                  - cfg (:obj:`Optional[dict]`): Configuration of the graph.
                  - dup_value (:obj:`Union[bool, Callable, type, Tuple[Type, ...]]`): Value duplicator, \
                      set `True` to make value with same id use the same node in graph, \
                      you can also define your own node id algorithm by this argument. \
                      Default is `False` which means do not use value duplicator.
                  - repr_gen (:obj:`Optional[Callable]`): Representation format generator, \
                      default is `None` which means using `repr` function.
                  - node_cfg_gen (:obj:`Optional[Callable]`): Node configuration generator, \
                      default is `None` which means no configuration.
                  - edge_cfg_gen (:obj:`Optional[Callable]`): Edge configuration generator, \
                      default is `None` which means no configuration.
  
              Returns:
                  - graph (:obj:`Digraph`): Generated graph of tree values.
              """
              return graphics(
                  *trees, title=title, cfg=cfg, dup_value=dup_value,
                  repr_gen=repr_gen, node_cfg_gen=node_cfg_gen, edge_cfg_gen=edge_cfg_gen,
              )
  
          @_decorate_treelize
          def __add__(self, other):
              """
              Overview:
                  Add tree values together.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 11, 'b': 22, 'x': {'c': 30, 'd': 40}})
                  >>> t1 + t2  # FastTreeValue({'a': 12, 'b': 24, 'x': {'c': 33, 'd': 44}})
              """
              return self + other
  
          @_decorate_treelize
          def __radd__(self, other):
              """
              Overview:
                  Right version of `__add__`.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> 1 + t1  # FastTreeValue({'a': 2, 'b': 3, 'x': {'c': 4, 'd': 5}})
              """
              return other + self
  
          @_decorate_and_replace
          def __iadd__(self, other):
              """
              Overview:
                  Self version of `__add__`.
                  Original id of self will be kept.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 11, 'b': 22, 'x': {'c': 30, 'd': 40}})
                  >>> t1 += t2
                  >>> t1 # t1's id will not change, FastTreeValue({'a': 12, 'b': 24, 'x': {'c': 33, 'd': 44}})
              """
              self += other
              return self
  
          @_decorate_treelize
          def __sub__(self, other):
              """
              Overview:
                  Substract tree values.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 11, 'b': 22, 'x': {'c': 30, 'd': 40}})
                  >>> t1 - t2  # FastTreeValue({'a': -10, 'b': -20, 'x': {'c': -27, 'd': -36}})
              """
              return self - other
  
          @_decorate_treelize
          def __rsub__(self, other):
              """
              Overview:
                  Right version of `__sub__`.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> 1 - t1  # FastTreeValue({'a': 0, 'b': -1, 'x': {'c': -2, 'd': -3}})
              """
              return other - self
  
          @_decorate_and_replace
          def __isub__(self, other):
              """
              Overview:
                  Self version of `__sub__`.
                  Original id of self will be kept.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 11, 'b': 22, 'x': {'c': 30, 'd': 40}})
                  >>> t1 -= t2
                  >>> t1 # t1's id will not change, FastTreeValue({'a': -10, 'b': -20, 'x': {'c': -27, 'd': -36}})
              """
              self -= other
              return self
  
          @_decorate_treelize
          def __mul__(self, other):
              """
              Overview:
                  Multiply tree values together.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 11, 'b': 22, 'x': {'c': 30, 'd': 40}})
                  >>> t1 * t2  # FastTreeValue({'a': 11, 'b': 44, 'x': {'c': 90, 'd': 160}})
              """
              return self * other
  
          @_decorate_treelize
          def __rmul__(self, other):
              """
              Overview:
                  Right version of `__mul__`.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> 2 * t1  # FastTreeValue({'a': 2, 'b': 4, 'x': {'c': 6, 'd': 8}})
              """
              return other * self
  
          @_decorate_and_replace
          def __imul__(self, other):
              """
              Overview:
                  Self version of `__mul__`.
                  Original id of self will be kept.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 11, 'b': 22, 'x': {'c': 30, 'd': 40}})
                  >>> t1 *= t2
                  >>> t1 # t1's id will not change, FastTreeValue({'a': 11, 'b': 44, 'x': {'c': 90, 'd': 160}})
              """
              self *= other
              return self
  
          @_decorate_treelize
          def __matmul__(self, other):
              """
              Overview:
                  Matrix tree values together, can be used in numpy or torch.
              """
              return self @ other
  
          @_decorate_treelize
          def __rmatmul__(self, other):
              """
              Overview:
                  Right version of `__matmul__`.
              """
              return other @ self
  
          @_decorate_and_replace
          def __imatmul__(self, other):
              """
              Overview:
                  Self version of `__matmul__`.
                  Original id of self will be kept.
              """
              self @= other
              return self
  
          @_decorate_treelize
          def __truediv__(self, other):
              """
              Overview:
                  True divide tree values.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 10, 'b': 25, 'x': {'c': 30, 'd': 40}})
                  >>> t1 / t2  # FastTreeValue({'a': 0.1, 'b': 0.08, 'x': {'c': 0.1, 'd': 0.1}})
              """
              return self / other
  
          @_decorate_treelize
          def __rtruediv__(self, other):
              """
              Overview:
                  Right version of `__truediv__`.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> 6 / t1  # FastTreeValue({'a': 6, 'b': 3, 'x': {'c': 2, 'd': 1.5}})
              """
              return other / self
  
          @_decorate_and_replace
          def __itruediv__(self, other):
              """
              Overview:
                  Self version of `__truediv__`.
                  Original id of self will be kept.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 10, 'b': 25, 'x': {'c': 30, 'd': 40}})
                  >>> t1 /= t2
                  >>> t1 # t1's id will not change, FastTreeValue({'a': 0.1, 'b': 0.08, 'x': {'c': 0.1, 'd': 0.1}})
              """
              self /= other
              return self
  
          @_decorate_treelize
          def __floordiv__(self, other):
              """
              Overview:
                  Floor divide tree values.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 10, 'b': 25, 'x': {'c': 30, 'd': 40}})
                  >>> t2 // t1  # FastTreeValue({'a': 10, 'b': 12, 'x': {'c': 10, 'd': 10}})
              """
              return self // other
  
          @_decorate_treelize
          def __rfloordiv__(self, other):
              """
              Overview:
                  Right version of `__floordiv__`.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> 6 // t1  # FastTreeValue({'a': 6, 'b': 3, 'x': {'c': 2, 'd': 1}})
              """
              return other // self
  
          @_decorate_and_replace
          def __ifloordiv__(self, other):
              """
              Overview:
                  Self version of `__floordiv__`.
                  Original id of self will be kept.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 10, 'b': 25, 'x': {'c': 30, 'd': 40}})
                  >>> t2 //= t1
                  >>> t2 # t2's id will not change, FastTreeValue({'a': 10, 'b': 12, 'x': {'c': 10, 'd': 10}})
              """
              self //= other
              return self
  
          @_decorate_treelize
          def __mod__(self, other):
              """
              Overview:
                  Mod tree values.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 10, 'b': 25, 'x': {'c': 30, 'd': 40}})
                  >>> t2 % t1  # FastTreeValue({'a': 0, 'b': 1, 'x': {'c': 0, 'd': 0}})
              """
              return self % other
  
          @_decorate_treelize
          def __rmod__(self, other):
              """
              Overview:
                  Right version of `__mod__`.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> 6 % t1  # FastTreeValue({'a': 0, 'b': 0, 'x': {'c': 0, 'd': 2}})
              """
              return other % self
  
          @_decorate_and_replace
          def __imod__(self, other):
              """
              Overview:
                  Self version of `__mod__`.
                  Original id of self will be kept.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 10, 'b': 25, 'x': {'c': 30, 'd': 40}})
                  >>> t2 %= t1
                  >>> t2 # t2's id will not change, FastTreeValue({'a': 0, 'b': 1, 'x': {'c': 0, 'd': 0}})
              """
              self %= other
              return self
  
          @_decorate_treelize
          def __pow__(self, power):
              """
              Overview:
                  Mod tree values.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 2, 'b': 3, 'x': {'c': 4, 'd': 5}})
                  >>> t1 ** t2  # FastTreeValue({'a': 1, 'b': 8, 'x': {'c': 81, 'd': 1024}})
              """
              return self ** power
  
          @_decorate_treelize
          def __rpow__(self, other):
              """
              Overview:
                  Right version of `__pow__`.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> 2 ** t1  # FastTreeValue({'a': 2, 'b': 4, 'x': {'c': 8, 'd': 16}})
              """
              return other ** self
  
          @_decorate_and_replace
          def __ipow__(self, other):
              """
              Overview:
                  Self version of `__pow__`.
                  Original id of self will be kept.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 2, 'b': 3, 'x': {'c': 4, 'd': 5}})
                  >>> t1 **= t2
                  >>> t1 # t1's id will not change, FastTreeValue({'a': 1, 'b': 8, 'x': {'c': 81, 'd': 1024}})
              """
              self **= other
              return self
  
          @_decorate_treelize
          def __and__(self, other):
              """
              Overview:
                  Bitwise and tree values.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 2, 'b': 3, 'x': {'c': 4, 'd': 5}})
                  >>> t1 & t2  # FastTreeValue({'a': 0, 'b': 2, 'x': {'c': 0, 'd': 4}})
              """
              return self & other
  
          @_decorate_treelize
          def __rand__(self, other):
              """
              Overview:
                  Right version of `__and__`.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> 5 & t1  # FastTreeValue({'a': 1, 'b': 0, 'x': {'c': 1, 'd': 4}})
              """
              return other & self
  
          @_decorate_and_replace
          def __iand__(self, other):
              """
              Overview:
                  Self version of `__and__`.
                  Original id of self will be kept.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 2, 'b': 3, 'x': {'c': 4, 'd': 5}})
                  >>> t1 &= t2
                  >>> t1 # t1's id will not change, FastTreeValue({'a': 0, 'b': 2, 'x': {'c': 0, 'd': 4}})
              """
              self &= other
              return self
  
          @_decorate_treelize
          def __or__(self, other):
              """
              Overview:
                  Bitwise or tree values.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 2, 'b': 3, 'x': {'c': 4, 'd': 5}})
                  >>> t1 | t2  # FastTreeValue({'a': 3, 'b': 3, 'x': {'c': 7, 'd': 5}})
              """
              return self | other
  
          @_decorate_treelize
          def __ror__(self, other):
              """
              Overview:
                  Right version of `__or__`.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> 5 | t1  # FastTreeValue({'a': 5, 'b': 7, 'x': {'c': 7, 'd': 5}})
              """
              return other | self
  
          @_decorate_and_replace
          def __ior__(self, other):
              """
              Overview:
                  Self version of `__or__`.
                  Original id of self will be kept.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 2, 'b': 3, 'x': {'c': 4, 'd': 5}})
                  >>> t1 |= t2
                  >>> t1 # t1's id will not change, FastTreeValue({'a': 3, 'b': 3, 'x': {'c': 7, 'd': 5}})
              """
              self |= other
              return self
  
          @_decorate_treelize
          def __xor__(self, other):
              """
              Overview:
                  Bitwise or tree values.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 2, 'b': 3, 'x': {'c': 4, 'd': 5}})
                  >>> t1 ^ t2  # FastTreeValue({'a': 3, 'b': 1, 'x': {'c': 7, 'd': 1}})
              """
              return self ^ other
  
          @_decorate_treelize
          def __rxor__(self, other):
              """
              Overview:
                  Right version of `__xor__`.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> 5 ^ t1  # FastTreeValue({'a': 4, 'b': 7, 'x': {'c': 6, 'd': 1}})
              """
              return other ^ self
  
          @_decorate_and_replace
          def __ixor__(self, other):
              """
              Overview:
                  Self version of `__xor__`.
                  Original id of self will be kept.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 2, 'b': 3, 'x': {'c': 4, 'd': 5}})
                  >>> t1 ^= t2
                  >>> t1 # t1's id will not change, FastTreeValue({'a': 3, 'b': 1, 'x': {'c': 7, 'd': 1}})
              """
              self ^= other
              return self
  
          @_decorate_treelize
          def __lshift__(self, other):
              """
              Overview:
                  Left shift tree values.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 2, 'b': 3, 'x': {'c': 4, 'd': 5}})
                  >>> t1 << t2  # FastTreeValue({'a': 4, 'b': 16, 'x': {'c': 48, 'd': 128}})
              """
              return self << other
  
          @_decorate_treelize
          def __rlshift__(self, other):
              """
              Overview:
                  Right version of `__lshift__`.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> 3 << t1  # FastTreeValue({'a': 6, 'b': 12, 'x': {'c': 24, 'd': 48}})
              """
              return other << self
  
          @_decorate_and_replace
          def __ilshift__(self, other):
              """
              Overview:
                  Self version of `__xor__`.
                  Original id of self will be kept.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 2, 'b': 3, 'x': {'c': 4, 'd': 5}})
                  >>> t1 <<= t2
                  >>> t1 # t1's id will not change, FastTreeValue({'a': 4, 'b': 16, 'x': {'c': 48, 'd': 128}})
              """
              self <<= other
              return self
  
          @_decorate_treelize
          def __rshift__(self, other):
              """
              Overview:
                  Left shift tree values.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 20, 'b': 30, 'x': {'c': 40, 'd': 50}})
                  >>> t2 >> t1  # FastTreeValue({'a': 10, 'b': 7, 'x': {'c': 5, 'd': 3}})
              """
              return self >> other
  
          @_decorate_treelize
          def __rrshift__(self, other):
              """
              Overview:
                  Right version of `__rshift__`.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> 64 >> t1  # FastTreeValue({'a': 32, 'b': 16, 'x': {'c': 8, 'd': 4}})
              """
              return other >> self
  
          @_decorate_and_replace
          def __irshift__(self, other):
              """
              Overview:
                  Self version of `__xor__`.
                  Original id of self will be kept.
  
              Example:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t2 = FastTreeValue({'a': 20, 'b': 30, 'x': {'c': 40, 'd': 50}})
                  >>> t2 >>= t1
                  >>> t2 # t2's id will not change, FastTreeValue({'a': 10, 'b': 7, 'x': {'c': 5, 'd': 3}})
              """
              self >>= other
              return self
  
          @_decorate_treelize
          def __pos__(self):
              """
              Overview:
                  Positive tree values.
  
              Examples:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> +t1  # FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
              """
              return +self
  
          @_decorate_treelize
          def __neg__(self):
              """
              Overview:
                  Negative tree values.
  
              Examples:
                  >>> t1 = FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> -t1  # FastTreeValue({'a': -1, 'b': -2, 'x': {'c': -3, 'd': -4}})
              """
              return -self
  
          @_decorate_treelize
          def __invert__(self):
              """
              Overview:
                  Bitwise invert tree values.
  
              Examples:
                  >>> t1 = FastTreeValue({'a': 1, 'b': -2, 'x': {'c': 3, 'd': -4}})
                  >>> ~t1  # FastTreeValue({'a': -2, 'b': 1, 'x': {'c': -4, 'd': 3}})
              """
              return ~self
  
          @_decorate_treelize
          def __getitem__(self, item):
              """
              Overview:
                  Get item of tree values.
  
              Examples:
                  >>> t1 = FastTreeValue({'a': [1, 2], 'b': [2, 3], 'x': {'c': [3, 4], 'd': [4, 5]}})
                  >>> t1[0]     # FastTreeValue({'a': 1, 'b': 2, 'x': {'c': 3, 'd': 4}})
                  >>> t1[-1]    # FastTreeValue({'a': 2, 'b': 3, 'x': {'c': 4, 'd': 5}})
                  >>> t1[::-1]  # FastTreeValue({'a': [2, 1], 'b': [3, 2], 'x': {'c': [4, 3], 'd': [5, 4]}})
              """
              return self[item]
  
          @_decorate_treelize
          def __setitem__(self, key, value):
              """
              Overview:
                  Set item of tree values.
  
              Examples:
                  >>> t1 = FastTreeValue({'a': [1, 2], 'b': [2, 3], 'x': {'c': [3, 4], 'd': [4, 5]}})
                  >>> t1[0] = -2  # FastTreeValue({'a': [-2, 2], 'b': [-2, 3], 'x': {'c': [-2, 4], 'd': [-2, 5]}})
                  >>> t1[0] = FastTreeValue({'a': 2, 'b': 3, 'x': {'c': 4, 'd': 5}})
                  >>> # FastTreeValue({'a': [2, 2], 'b': [3, 3], 'x': {'c': [4, 4], 'd': [5, 5]}})
              """
              self[key] = value
  
          @_decorate_treelize
          def __delitem__(self, key):
              """
              Overview:
                  Delete item of tree values.
  
              Examples:
                  >>> t1 = FastTreeValue({'a': [1, 2], 'b': [2, 3], 'x': {'c': [3, 4], 'd': [4, 5]}})
                  >>> del t1[0]  # FastTreeValue({'a': [2], 'b': [3], 'x': {'c': [4], 'd': [5]}})
              """
              del self[key]
  
          @_decorate_treelize
          def __call__(self, *args, **kwargs):
              """
              Overview:
                  Call of tree values.
  
              Example:
                  >>> class Container:
                  >>>     def __init__(self, value):
                  >>>         self.__value = value
                  >>>
                  >>>     def append(self, v):
                  >>>         return self.__value + v
                  >>>
                  >>> t = FastTreeValue({'a': Container(1), 'b': Container(2)})
                  >>> t.append(2)  # FastTreeValue({'a': 3, 'b': 4})
                  >>> t.append(FastTreeValue({'a': 10, 'b': 20}))  # FastTreeValue({'a': 11, 'b': 22})
              """
              return self(*args, **kwargs)
  
      return _GeneralTreeValue
  