code: def combine_tensors_and_multiply(combination: str,
                                   tensors: List[torch.Tensor],
                                   weights: torch.nn.Parameter) -> torch.Tensor:
      
      if len(tensors) > 9:
          raise ConfigurationError("Double-digit tensor lists not currently supported")
      combination = combination.replace('x', '1').replace('y', '2')
      pieces = combination.split(',')
      tensor_dims = [tensor.size(-1) for tensor in tensors]
      combination_dims = [_get_combination_dim(piece, tensor_dims) for piece in pieces]
      dims_so_far = 0
      to_sum = []
      for piece, combination_dim in zip(pieces, combination_dims):
          weight = weights[dims_so_far:(dims_so_far + combination_dim)]
          dims_so_far += combination_dim
          to_sum.append(_get_combination_and_multiply(piece, tensors, weight))
      result = to_sum[0]
      for result_piece in to_sum[1:]:
          result = result + result_piece
      return result
docs: Like :func:`combine_tensors`, but does a weighted (linear) multiplication while combining.
      This is a separate function from ``combine_tensors`` because we try to avoid instantiating
      large intermediate tensors during the combination, which is possible because we know that we're
      going to be multiplying by a weight vector in the end.
  
      Parameters
      ----------
      combination : ``str``
          Same as in :func:`combine_tensors`
      tensors : ``List[torch.Tensor]``
          A list of tensors to combine, where the integers in the ``combination`` are (1-indexed)
          positions in this list of tensors.  These tensors are all expected to have either three or
          four dimensions, with the final dimension being an embedding.  If there are four
          dimensions, one of them must have length 1.
      weights : ``torch.nn.Parameter``
          A vector of weights to use for the combinations.  This should have shape (combined_dim,),
          as calculated by :func:`get_combined_dim`.