code: async def _load_tuple(self, reader, elem_type, params=None, elem=None):
          
  
          c_len = await load_uvarint(reader)
          if elem and c_len != len(elem):
              raise ValueError("Size mismatch")
          if c_len != len(elem_type.f_specs()):
              raise ValueError("Tuple size mismatch")
  
          elem_fields = params[0] if params else None
          if elem_fields is None:
              elem_fields = elem_type.f_specs()
  
          res = elem if elem else []
          for i in range(c_len):
              try:
                  self.tracker.push_index(i)
                  fvalue = await self.load_field(
                      reader,
                      elem_fields[i],
                      params[1:] if params else None,
                      eref(res, i) if elem else None,
                  )
                  self.tracker.pop()
              except Exception as e:
                  raise helpers.ArchiveException(e, tracker=self.tracker) from e
  
              if not elem:
                  res.append(fvalue)
          return res
docs: Loads tuple of elements from the reader. Supports the tuple ref.
          Returns loaded tuple.
  
          :param reader:
          :param elem_type:
          :param params:
          :param container:
          :return: