class_docstr: A Tensor subclass of uint8 dtype, that represents Tensor with X-bit elements.
  The last dimension must be divisible by (8 // X).
  
  __torch_dispatch__ special handling:
  .view(dtype=torch.uint8) - returns the underlying uint8 data.
  
  .slice,.view - works in UIntX units, dimension values must be divisible by (8 // X).
  
  .detach,.clone - work as an op on underlying uint8 data.
code: def __torch_dispatch__(
      cls, func, types, args, kwargs=None
  ):  # noqa: C901
      if func is torch.ops.aten.detach.default:
          # Temp workaround to avoid 'Cannot set version_counter for inference tensor'
          with torch.inference_mode(False):
              (self,) = args
              return cls(func(self.elem))
      elif func is torch.ops.aten.clone.default:
          (self,) = args
          return cls(func(self.elem))
      elif func is torch.ops.aten.copy_.default:
          (self, src) = args
          self.elem.copy_(src.elem)
          return self
      elif func is torch.ops.aten.view.dtype:
          # .view(dtype=uint8) is the way to get the underlying uint8 data
          self, dtype = args
          if dtype == torch.uint8:
              return self.elem
      elif func is torch.ops.aten._to_copy.default:
          (self,) = args
          dtype = find_arg_of_type(
              itertools.chain(args, kwargs.values()), torch.dtype
          )
          device = find_arg_of_type(
              itertools.chain(args, kwargs.values()), torch.device
          )
          # Handle only to device
          if device:
              assert dtype is None or dtype == torch.uint8
              return cls(self.elem.to(device))
      elif func is torch.ops.aten.slice.Tensor:
          self, dim, start, end, step = fill_defaults(
              args, 5, [0, None, None, 1]
          )
          if dim == self.dim() - 1:
              # hard case
              if step != 1:
                  raise NotImplementedError(f"slice step={step}")
              assert start % self.N == 0, start
              assert end >= self.shape[dim] or end % self.N == 0, end
              return cls(
                  torch.ops.aten.slice.Tensor(
                      self.elem, dim, start // self.N, end // self.N, 1
                  ),
              )
          else:
              return cls(
                  torch.ops.aten.slice.Tensor(
                      self.elem, dim, start, end, step
                  ),
              )
      if func is torch.ops.aten.view.default:
          self, size = args
          size = utils.infer_size(size, self.numel())
          assert not kwargs
          return cls(self.elem.reshape(down_size(self.N, size)))
      elif func is torch.ops.aten.select.int:
          self, dim, index = args
          if dim != self.dim() - 1:
              return cls(
                  torch.ops.aten.select.int(self.elem, dim, index)
              )
          else:
              raise NotImplementedError(f"select dim={dim}")
  
      raise NotImplementedError(f"{func} args:{args} kwargs:{kwargs}")
  
imports: import itertools
  from typing import List, Tuple
  import torch
  import torch._prims_common
label_desc: Use image node_id 5 for calling the UIntXTensor obj's underlying member method code with example usage: obj.__torch_dispatch__(cls, func, types, args, kwargs) and returns: cls, cls, cls, self, cls, self, cls, cls, cls