code: def _broadcast_ragged_sources_for_overlap(
      source_start, source_limit, target_splits
  ):
      """Repeats source indices for each target item in the same batch.
  
      Args:
        source_start: `<int>[batch_size, (source_size)]`
        source_limit: `<int>[batch_size, (source_size)]`
        target_splits: `<int64>[batch_size, (target_size+1)]`
  
      Returns:
        `<int>[batch_size, (source_size), (target_size)]`.
        A tuple of tensors `(tiled_source_start, tiled_source_limit)` where:
  
        * `tiled_target_start[b, s, t] = source_start[b, s]`
        * `tiled_target_limit[b, s, t] = source_limit[b, s]`
      """
      source_splits = source_start.row_splits
      target_rowlens = target_splits[1:] - target_splits[:-1]
      source_batch_ids = segment_id_ops.row_splits_to_segment_ids(
          source_splits
      )
  
      # <int64>[sum(source_size[b] for b in range(batch_size))]
      # source_repeats[i] is the number of target spans in the batch that contains
      # source span i.  We need to add a new ragged dimension that repeats each
      # source span this number of times.
      source_repeats = ragged_gather_ops.gather(
          target_rowlens, source_batch_ids
      )
  
      # <int64>[sum(source_size[b] for b in range(batch_size)) + 1]
      # The row_splits tensor for the inner ragged dimension of the result tensors.
      inner_splits = array_ops.concat(
          [[0], math_ops.cumsum(source_repeats)], axis=0
      )
  
      # <int64>[sum(source_size[b] * target_size[b] for b in range(batch_size))]
      # Indices for gathering source indices.
      source_indices = segment_id_ops.row_splits_to_segment_ids(
          inner_splits
      )
  
      source_start = ragged_tensor.RaggedTensor.from_nested_row_splits(
          array_ops.gather(source_start.values, source_indices),
          [source_splits, inner_splits],
      )
      source_limit = ragged_tensor.RaggedTensor.from_nested_row_splits(
          array_ops.gather(source_limit.values, source_indices),
          [source_splits, inner_splits],
      )
  
      return source_start, source_limit
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import functools
  from tensorflow.python.framework import dtypes
  from tensorflow.python.framework import ops
  from tensorflow.python.framework import tensor
  from tensorflow.python.ops import array_ops
  from tensorflow.python.ops import array_ops_stack
  from tensorflow.python.ops import check_ops
  from tensorflow.python.ops import math_ops
  from tensorflow.python.ops.ragged import ragged_functional_ops
  from tensorflow.python.ops.ragged import ragged_gather_ops
  from tensorflow.python.ops.ragged import ragged_math_ops
  from tensorflow.python.ops.ragged import ragged_tensor
  from tensorflow.python.ops.ragged import ragged_where_op
  from tensorflow.python.ops.ragged import segment_id_ops
label_desc: Use image node_id 5 for calling a global function with example usage: _broadcast_ragged_sources_for_overlap(source_start, source_limit, target_splits) and returns: source_start,  source_limit