gemini-code-assist[bot] commented on code in PR #19616:
URL: https://github.com/apache/tvm/pull/19616#discussion_r3305572629
##########
python/tvm/relax/frontend/tflite/tflite_frontend.py:
##########
@@ -1888,6 +1900,408 @@ def _convert_stablehlo_sort(self, op):
relax.op.sort(data, axis=int(opts.Dimension()),
descending=descending)
)
+ def _get_builtin_options(self, op, options_cls):
+ """Parse BuiltinOptions for a TFLite builtin operator."""
+ from tflite.BuiltinOptions import BuiltinOptions
+
+ op_options = op.BuiltinOptions()
+ if op_options is None:
+ raise tvm.error.OpNotImplemented(f"{options_cls.__name__} is
required")
+
+ options_type = getattr(BuiltinOptions, options_cls.__name__, None)
+ if options_type is not None and op.BuiltinOptionsType() !=
options_type:
+ raise tvm.error.OpNotImplemented(
+ f"Unexpected BuiltinOptions type: expected "
+ f"{options_cls.__name__}, got {op.BuiltinOptionsType()}"
+ )
+ result = options_cls()
+ result.Init(op_options.Bytes, op_options.Pos)
+ return result
+
+ def _get_subgraph(self, subgraph_index, op_name, allow_main=False):
+ """Return a validated TFLite subgraph by index."""
+ if subgraph_index < 0 or subgraph_index >=
self.model.SubgraphsLength():
+ raise tvm.error.OpNotImplemented(f"{op_name} requires a valid
subgraph index")
+ if not allow_main and subgraph_index == 0:
+ raise tvm.error.OpNotImplemented(f"{op_name} cannot target the
main subgraph")
+ return self.model.Subgraphs(subgraph_index)
+
+ def _make_tuple_or_single(self, exprs):
+ """Return a single expression or Relax tuple for a list of
expressions."""
+ if len(exprs) == 1:
+ return exprs[0]
+ return relax.Tuple(exprs)
+
+ def _check_subgraph_io(self, subgraph_index, op_name, input_count=None,
output_count=None):
+ """Validate a referenced subgraph's input and output counts."""
+ subgraph = self._get_subgraph(subgraph_index, op_name)
+ if input_count is not None and subgraph.InputsLength() != input_count:
+ raise tvm.error.OpNotImplemented(f"{op_name} subgraph input count
mismatch")
+ if output_count is not None and subgraph.OutputsLength() !=
output_count:
+ raise tvm.error.OpNotImplemented(f"{op_name} subgraph output count
mismatch")
+ return subgraph
+
+ def _check_subgraph_interface(
+ self,
+ subgraph_index,
+ op_name,
+ input_tensors=None,
+ output_tensors=None,
+ input_count=None,
+ output_count=None,
+ ):
+ """Validate a referenced subgraph's arity and tensor metadata."""
+ if input_tensors is not None:
+ input_count = len(input_tensors)
+ if output_tensors is not None:
+ output_count = len(output_tensors)
+
+ subgraph = self._check_subgraph_io(
+ subgraph_index, op_name, input_count=input_count,
output_count=output_count
+ )
+ if input_tensors is not None:
+ self._check_subgraph_tensor_metadata(
+ subgraph,
+ op_name,
+ "subgraph input",
+ subgraph.InputsAsNumpy(),
+ input_tensors,
+ )
+ if output_tensors is not None:
+ self._check_subgraph_tensor_metadata(
+ subgraph,
+ op_name,
+ "subgraph output",
+ subgraph.OutputsAsNumpy(),
+ output_tensors,
+ )
+ return subgraph
+
+ def _get_tensor_metadata(self, tensor):
+ """Return static shape and dtype metadata for a TFLite tensor."""
+ if isinstance(tensor, TensorWrapper):
+ tensor = tensor.tensor
+ shape = tuple(tensor.ShapeAsNumpy()) if tensor.ShapeLength() > 0 else
()
+ dtype = self.get_tensor_type_str(tensor.Type())
+ return shape, dtype
+
+ def _check_tensor_metadata_match(self, actual, expected, op_name,
tensor_role):
+ """Validate that two TFLite tensors have matching static metadata."""
+ if self._get_tensor_metadata(actual) !=
self._get_tensor_metadata(expected):
+ raise tvm.error.OpNotImplemented(f"{op_name} {tensor_role} tensor
metadata mismatch")
+
+ def _check_subgraph_tensor_metadata(
+ self, subgraph, op_name, tensor_role, subgraph_indices,
expected_tensors
+ ):
+ """Validate referenced subgraph tensor metadata against caller
tensors."""
+ for subgraph_index, expected_tensor in zip(subgraph_indices,
expected_tensors):
+ self._check_tensor_metadata_match(
+ subgraph.Tensors(int(subgraph_index)),
+ expected_tensor,
+ op_name,
+ tensor_role,
+ )
+
+ def _require_scalar_bool_tensor(self, tensor, op_name):
+ """Validate that a TFLite tensor is a scalar bool tensor."""
+ if isinstance(tensor, TensorWrapper):
+ tensor = tensor.tensor
+ dtype = self.get_tensor_type_str(tensor.Type())
+ if dtype != "bool" or tensor.ShapeLength() != 0:
+ raise tvm.error.OpNotImplemented(f"{op_name} requires a scalar
bool condition")
+
+ def _get_subgraph_params(self, subgraph):
+ """Create Relax parameters for a TFLite subgraph."""
+ params = []
+ exp_tab = ExprTable()
+ for input_index in subgraph.InputsAsNumpy():
Review Comment:
If the subgraph has 0 inputs, `subgraph.InputsAsNumpy()` returns `None` in
the flatbuffers Python API. Iterating over `None` will raise a `TypeError`. We
should safely handle the `None` case. Note that using `subgraph.InputsAsNumpy()
or []` is unsafe because if it returns a non-empty numpy array, evaluating its
truth value will raise a `ValueError` due to ambiguity. Using an explicit `is
not None` check is the correct and safe approach.
```suggestion
subgraph_inputs = subgraph.InputsAsNumpy() if
subgraph.InputsAsNumpy() is not None else []
for input_index in subgraph_inputs:
```
##########
python/tvm/relax/frontend/tflite/tflite_frontend.py:
##########
@@ -1888,6 +1900,408 @@ def _convert_stablehlo_sort(self, op):
relax.op.sort(data, axis=int(opts.Dimension()),
descending=descending)
)
+ def _get_builtin_options(self, op, options_cls):
+ """Parse BuiltinOptions for a TFLite builtin operator."""
+ from tflite.BuiltinOptions import BuiltinOptions
+
+ op_options = op.BuiltinOptions()
+ if op_options is None:
+ raise tvm.error.OpNotImplemented(f"{options_cls.__name__} is
required")
+
+ options_type = getattr(BuiltinOptions, options_cls.__name__, None)
+ if options_type is not None and op.BuiltinOptionsType() !=
options_type:
+ raise tvm.error.OpNotImplemented(
+ f"Unexpected BuiltinOptions type: expected "
+ f"{options_cls.__name__}, got {op.BuiltinOptionsType()}"
+ )
+ result = options_cls()
+ result.Init(op_options.Bytes, op_options.Pos)
+ return result
+
+ def _get_subgraph(self, subgraph_index, op_name, allow_main=False):
+ """Return a validated TFLite subgraph by index."""
+ if subgraph_index < 0 or subgraph_index >=
self.model.SubgraphsLength():
+ raise tvm.error.OpNotImplemented(f"{op_name} requires a valid
subgraph index")
+ if not allow_main and subgraph_index == 0:
+ raise tvm.error.OpNotImplemented(f"{op_name} cannot target the
main subgraph")
+ return self.model.Subgraphs(subgraph_index)
+
+ def _make_tuple_or_single(self, exprs):
+ """Return a single expression or Relax tuple for a list of
expressions."""
+ if len(exprs) == 1:
+ return exprs[0]
+ return relax.Tuple(exprs)
+
+ def _check_subgraph_io(self, subgraph_index, op_name, input_count=None,
output_count=None):
+ """Validate a referenced subgraph's input and output counts."""
+ subgraph = self._get_subgraph(subgraph_index, op_name)
+ if input_count is not None and subgraph.InputsLength() != input_count:
+ raise tvm.error.OpNotImplemented(f"{op_name} subgraph input count
mismatch")
+ if output_count is not None and subgraph.OutputsLength() !=
output_count:
+ raise tvm.error.OpNotImplemented(f"{op_name} subgraph output count
mismatch")
+ return subgraph
+
+ def _check_subgraph_interface(
+ self,
+ subgraph_index,
+ op_name,
+ input_tensors=None,
+ output_tensors=None,
+ input_count=None,
+ output_count=None,
+ ):
+ """Validate a referenced subgraph's arity and tensor metadata."""
+ if input_tensors is not None:
+ input_count = len(input_tensors)
+ if output_tensors is not None:
+ output_count = len(output_tensors)
+
+ subgraph = self._check_subgraph_io(
+ subgraph_index, op_name, input_count=input_count,
output_count=output_count
+ )
+ if input_tensors is not None:
+ self._check_subgraph_tensor_metadata(
+ subgraph,
+ op_name,
+ "subgraph input",
+ subgraph.InputsAsNumpy(),
+ input_tensors,
+ )
+ if output_tensors is not None:
+ self._check_subgraph_tensor_metadata(
+ subgraph,
+ op_name,
+ "subgraph output",
+ subgraph.OutputsAsNumpy(),
+ output_tensors,
+ )
+ return subgraph
+
+ def _get_tensor_metadata(self, tensor):
+ """Return static shape and dtype metadata for a TFLite tensor."""
+ if isinstance(tensor, TensorWrapper):
+ tensor = tensor.tensor
+ shape = tuple(tensor.ShapeAsNumpy()) if tensor.ShapeLength() > 0 else
()
+ dtype = self.get_tensor_type_str(tensor.Type())
+ return shape, dtype
+
+ def _check_tensor_metadata_match(self, actual, expected, op_name,
tensor_role):
+ """Validate that two TFLite tensors have matching static metadata."""
+ if self._get_tensor_metadata(actual) !=
self._get_tensor_metadata(expected):
+ raise tvm.error.OpNotImplemented(f"{op_name} {tensor_role} tensor
metadata mismatch")
+
+ def _check_subgraph_tensor_metadata(
+ self, subgraph, op_name, tensor_role, subgraph_indices,
expected_tensors
+ ):
+ """Validate referenced subgraph tensor metadata against caller
tensors."""
+ for subgraph_index, expected_tensor in zip(subgraph_indices,
expected_tensors):
+ self._check_tensor_metadata_match(
+ subgraph.Tensors(int(subgraph_index)),
+ expected_tensor,
+ op_name,
+ tensor_role,
+ )
+
+ def _require_scalar_bool_tensor(self, tensor, op_name):
+ """Validate that a TFLite tensor is a scalar bool tensor."""
+ if isinstance(tensor, TensorWrapper):
+ tensor = tensor.tensor
+ dtype = self.get_tensor_type_str(tensor.Type())
+ if dtype != "bool" or tensor.ShapeLength() != 0:
+ raise tvm.error.OpNotImplemented(f"{op_name} requires a scalar
bool condition")
+
+ def _get_subgraph_params(self, subgraph):
+ """Create Relax parameters for a TFLite subgraph."""
+ params = []
+ exp_tab = ExprTable()
+ for input_index in subgraph.InputsAsNumpy():
+ tensor = subgraph.Tensors(int(input_index))
+ input_name = get_tensor_name(subgraph, int(input_index))
+ shape = tuple(tensor.ShapeAsNumpy()) if tensor.ShapeLength() > 0
else []
+ dtype = _decode_type(tensor.Type())
Review Comment:
For consistency with other parts of the class (such as `_get_tensor_param`),
we should use `self.get_tensor_type_str(tensor.Type())` instead of calling the
module-level `_decode_type` directly.
```suggestion
dtype = self.get_tensor_type_str(tensor.Type())
```
##########
python/tvm/relax/frontend/tflite/tflite_frontend.py:
##########
@@ -1888,6 +1900,408 @@ def _convert_stablehlo_sort(self, op):
relax.op.sort(data, axis=int(opts.Dimension()),
descending=descending)
)
+ def _get_builtin_options(self, op, options_cls):
+ """Parse BuiltinOptions for a TFLite builtin operator."""
+ from tflite.BuiltinOptions import BuiltinOptions
+
+ op_options = op.BuiltinOptions()
+ if op_options is None:
+ raise tvm.error.OpNotImplemented(f"{options_cls.__name__} is
required")
+
+ options_type = getattr(BuiltinOptions, options_cls.__name__, None)
+ if options_type is not None and op.BuiltinOptionsType() !=
options_type:
+ raise tvm.error.OpNotImplemented(
+ f"Unexpected BuiltinOptions type: expected "
+ f"{options_cls.__name__}, got {op.BuiltinOptionsType()}"
+ )
+ result = options_cls()
+ result.Init(op_options.Bytes, op_options.Pos)
+ return result
+
+ def _get_subgraph(self, subgraph_index, op_name, allow_main=False):
+ """Return a validated TFLite subgraph by index."""
+ if subgraph_index < 0 or subgraph_index >=
self.model.SubgraphsLength():
+ raise tvm.error.OpNotImplemented(f"{op_name} requires a valid
subgraph index")
+ if not allow_main and subgraph_index == 0:
+ raise tvm.error.OpNotImplemented(f"{op_name} cannot target the
main subgraph")
+ return self.model.Subgraphs(subgraph_index)
+
+ def _make_tuple_or_single(self, exprs):
+ """Return a single expression or Relax tuple for a list of
expressions."""
+ if len(exprs) == 1:
+ return exprs[0]
+ return relax.Tuple(exprs)
+
+ def _check_subgraph_io(self, subgraph_index, op_name, input_count=None,
output_count=None):
+ """Validate a referenced subgraph's input and output counts."""
+ subgraph = self._get_subgraph(subgraph_index, op_name)
+ if input_count is not None and subgraph.InputsLength() != input_count:
+ raise tvm.error.OpNotImplemented(f"{op_name} subgraph input count
mismatch")
+ if output_count is not None and subgraph.OutputsLength() !=
output_count:
+ raise tvm.error.OpNotImplemented(f"{op_name} subgraph output count
mismatch")
+ return subgraph
+
+ def _check_subgraph_interface(
+ self,
+ subgraph_index,
+ op_name,
+ input_tensors=None,
+ output_tensors=None,
+ input_count=None,
+ output_count=None,
+ ):
+ """Validate a referenced subgraph's arity and tensor metadata."""
+ if input_tensors is not None:
+ input_count = len(input_tensors)
+ if output_tensors is not None:
+ output_count = len(output_tensors)
+
+ subgraph = self._check_subgraph_io(
+ subgraph_index, op_name, input_count=input_count,
output_count=output_count
+ )
+ if input_tensors is not None:
+ self._check_subgraph_tensor_metadata(
+ subgraph,
+ op_name,
+ "subgraph input",
+ subgraph.InputsAsNumpy(),
+ input_tensors,
+ )
+ if output_tensors is not None:
+ self._check_subgraph_tensor_metadata(
+ subgraph,
+ op_name,
+ "subgraph output",
+ subgraph.OutputsAsNumpy(),
+ output_tensors,
+ )
+ return subgraph
+
+ def _get_tensor_metadata(self, tensor):
+ """Return static shape and dtype metadata for a TFLite tensor."""
+ if isinstance(tensor, TensorWrapper):
+ tensor = tensor.tensor
+ shape = tuple(tensor.ShapeAsNumpy()) if tensor.ShapeLength() > 0 else
()
+ dtype = self.get_tensor_type_str(tensor.Type())
+ return shape, dtype
+
+ def _check_tensor_metadata_match(self, actual, expected, op_name,
tensor_role):
+ """Validate that two TFLite tensors have matching static metadata."""
+ if self._get_tensor_metadata(actual) !=
self._get_tensor_metadata(expected):
+ raise tvm.error.OpNotImplemented(f"{op_name} {tensor_role} tensor
metadata mismatch")
+
+ def _check_subgraph_tensor_metadata(
+ self, subgraph, op_name, tensor_role, subgraph_indices,
expected_tensors
+ ):
+ """Validate referenced subgraph tensor metadata against caller
tensors."""
+ for subgraph_index, expected_tensor in zip(subgraph_indices,
expected_tensors):
Review Comment:
If `subgraph_indices` is `None` (which happens when the subgraph has 0
inputs or outputs), calling `zip(None, expected_tensors)` will raise a
`TypeError`. We should safely handle the `None` case before zipping.
```python
indices = subgraph_indices if subgraph_indices is not None else []
for subgraph_index, expected_tensor in zip(indices,
expected_tensors):
```
##########
python/tvm/relax/frontend/tflite/tflite_frontend.py:
##########
@@ -1888,6 +1900,408 @@ def _convert_stablehlo_sort(self, op):
relax.op.sort(data, axis=int(opts.Dimension()),
descending=descending)
)
+ def _get_builtin_options(self, op, options_cls):
+ """Parse BuiltinOptions for a TFLite builtin operator."""
+ from tflite.BuiltinOptions import BuiltinOptions
+
+ op_options = op.BuiltinOptions()
+ if op_options is None:
+ raise tvm.error.OpNotImplemented(f"{options_cls.__name__} is
required")
+
+ options_type = getattr(BuiltinOptions, options_cls.__name__, None)
+ if options_type is not None and op.BuiltinOptionsType() !=
options_type:
+ raise tvm.error.OpNotImplemented(
+ f"Unexpected BuiltinOptions type: expected "
+ f"{options_cls.__name__}, got {op.BuiltinOptionsType()}"
+ )
+ result = options_cls()
+ result.Init(op_options.Bytes, op_options.Pos)
+ return result
+
+ def _get_subgraph(self, subgraph_index, op_name, allow_main=False):
+ """Return a validated TFLite subgraph by index."""
+ if subgraph_index < 0 or subgraph_index >=
self.model.SubgraphsLength():
+ raise tvm.error.OpNotImplemented(f"{op_name} requires a valid
subgraph index")
+ if not allow_main and subgraph_index == 0:
+ raise tvm.error.OpNotImplemented(f"{op_name} cannot target the
main subgraph")
+ return self.model.Subgraphs(subgraph_index)
+
+ def _make_tuple_or_single(self, exprs):
+ """Return a single expression or Relax tuple for a list of
expressions."""
+ if len(exprs) == 1:
+ return exprs[0]
+ return relax.Tuple(exprs)
+
+ def _check_subgraph_io(self, subgraph_index, op_name, input_count=None,
output_count=None):
+ """Validate a referenced subgraph's input and output counts."""
+ subgraph = self._get_subgraph(subgraph_index, op_name)
+ if input_count is not None and subgraph.InputsLength() != input_count:
+ raise tvm.error.OpNotImplemented(f"{op_name} subgraph input count
mismatch")
+ if output_count is not None and subgraph.OutputsLength() !=
output_count:
+ raise tvm.error.OpNotImplemented(f"{op_name} subgraph output count
mismatch")
+ return subgraph
+
+ def _check_subgraph_interface(
+ self,
+ subgraph_index,
+ op_name,
+ input_tensors=None,
+ output_tensors=None,
+ input_count=None,
+ output_count=None,
+ ):
+ """Validate a referenced subgraph's arity and tensor metadata."""
+ if input_tensors is not None:
+ input_count = len(input_tensors)
+ if output_tensors is not None:
+ output_count = len(output_tensors)
+
+ subgraph = self._check_subgraph_io(
+ subgraph_index, op_name, input_count=input_count,
output_count=output_count
+ )
+ if input_tensors is not None:
+ self._check_subgraph_tensor_metadata(
+ subgraph,
+ op_name,
+ "subgraph input",
+ subgraph.InputsAsNumpy(),
+ input_tensors,
+ )
+ if output_tensors is not None:
+ self._check_subgraph_tensor_metadata(
+ subgraph,
+ op_name,
+ "subgraph output",
+ subgraph.OutputsAsNumpy(),
+ output_tensors,
+ )
+ return subgraph
+
+ def _get_tensor_metadata(self, tensor):
+ """Return static shape and dtype metadata for a TFLite tensor."""
+ if isinstance(tensor, TensorWrapper):
+ tensor = tensor.tensor
+ shape = tuple(tensor.ShapeAsNumpy()) if tensor.ShapeLength() > 0 else
()
+ dtype = self.get_tensor_type_str(tensor.Type())
+ return shape, dtype
+
+ def _check_tensor_metadata_match(self, actual, expected, op_name,
tensor_role):
+ """Validate that two TFLite tensors have matching static metadata."""
+ if self._get_tensor_metadata(actual) !=
self._get_tensor_metadata(expected):
+ raise tvm.error.OpNotImplemented(f"{op_name} {tensor_role} tensor
metadata mismatch")
+
+ def _check_subgraph_tensor_metadata(
+ self, subgraph, op_name, tensor_role, subgraph_indices,
expected_tensors
+ ):
+ """Validate referenced subgraph tensor metadata against caller
tensors."""
+ for subgraph_index, expected_tensor in zip(subgraph_indices,
expected_tensors):
+ self._check_tensor_metadata_match(
+ subgraph.Tensors(int(subgraph_index)),
+ expected_tensor,
+ op_name,
+ tensor_role,
+ )
+
+ def _require_scalar_bool_tensor(self, tensor, op_name):
+ """Validate that a TFLite tensor is a scalar bool tensor."""
+ if isinstance(tensor, TensorWrapper):
+ tensor = tensor.tensor
+ dtype = self.get_tensor_type_str(tensor.Type())
+ if dtype != "bool" or tensor.ShapeLength() != 0:
+ raise tvm.error.OpNotImplemented(f"{op_name} requires a scalar
bool condition")
+
+ def _get_subgraph_params(self, subgraph):
+ """Create Relax parameters for a TFLite subgraph."""
+ params = []
+ exp_tab = ExprTable()
+ for input_index in subgraph.InputsAsNumpy():
+ tensor = subgraph.Tensors(int(input_index))
+ input_name = get_tensor_name(subgraph, int(input_index))
+ shape = tuple(tensor.ShapeAsNumpy()) if tensor.ShapeLength() > 0
else []
+ dtype = _decode_type(tensor.Type())
+ param = relax.Var(input_name, relax.TensorStructInfo(shape=shape,
dtype=dtype))
+ exp_tab.set_expr(input_name, param)
+ params.append(param)
+ return params, exp_tab
+
+ def _get_tensor_param(self, tensor_wrapper):
+ """Create a Relax parameter from TFLite tensor metadata."""
+ name = get_tensor_name(self.subgraph, tensor_wrapper.tensor_idx)
+ shape = (
+ tuple(tensor_wrapper.tensor.ShapeAsNumpy())
+ if tensor_wrapper.tensor.ShapeLength() > 0
+ else []
+ )
+ dtype = self.get_tensor_type_str(tensor_wrapper.tensor.Type())
+ return relax.Var(name, relax.TensorStructInfo(shape=shape,
dtype=dtype))
+
+ def _lower_subgraph_to_function(self, subgraph_index, function_name_hint,
op_name="CALL"):
+ """Lower a TFLite subgraph into a private Relax function."""
+ lowered_subgraphs = self.conversion_state["lowered_subgraphs"]
+ if subgraph_index in lowered_subgraphs:
+ return lowered_subgraphs[subgraph_index]
+
+ lowering_stack = self.conversion_state["lowering_stack"]
+ if subgraph_index in lowering_stack:
+ raise tvm.error.OpNotImplemented(
+ f"Recursive TFLite {op_name} subgraphs are not supported"
+ )
+
+ subgraph = self._get_subgraph(subgraph_index, op_name)
+ lowering_stack.append(subgraph_index)
+ try:
+ params, subgraph_exp_tab = self._get_subgraph_params(subgraph)
+ subgraph_bb = relax.BlockBuilder()
+ with subgraph_bb.function(function_name_hint, params=params,
private=True):
+ with subgraph_bb.dataflow():
+ subgraph_converter = type(self)(
+ self.model,
+ subgraph,
+ subgraph_exp_tab,
+ subgraph_bb,
+ self.conversion_state,
+ )
+ subgraph_converter.check_unsupported_ops()
+ subgraph_converter.convert_op_to_relax()
+ output_tensors =
subgraph_converter.get_tensors(subgraph.OutputsAsNumpy())
Review Comment:
If the subgraph has 0 outputs, `subgraph.OutputsAsNumpy()` returns `None` in
the flatbuffers Python API. Passing `None` to `get_tensors` might raise an
error. We should safely handle the `None` case.
```python
subgraph_outputs = subgraph.OutputsAsNumpy() if
subgraph.OutputsAsNumpy() is not None else []
output_tensors =
subgraph_converter.get_tensors(subgraph_outputs)
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
