code: def pad(
      data,
      pad_before,
      pad_after=None,
      pad_value=0.0,
      name="PadInput",
      attrs=None,
  ):
      """Pad Input with zeros.
  
      Parameters
      ----------
      data : tvm.te.Tensor
          n-D input, can be any layout.
  
      pad_before : list / tuple of n ints
          Pad width on each dimension to pad the before the axis begin.
  
      pad_after : list / tuple of n ints, optional
          Pad width each dimension to pad the after the axis end.
  
      pad_value : float, optional
          The value to be padded.
  
      name : str, optional
          The name prefix operators generated
  
      Returns
      -------
      Output : tvm.te.Tensor
          n-D, the same layout as Input.
      """
      n = len(data.shape)
      pad_after = pad_after if pad_after else pad_before
      if len(pad_before) != n:
          raise ValueError(
              f"Input dimension and pad_before dismatch : {n} vs {len(pad_before)}"
          )
      if len(pad_after) != n:
          raise ValueError(
              f"Input dimension and pad_after dismatch : {n} vs {len(pad_after)}"
          )
      ana = tvm.arith.Analyzer()
      dshape = []
      for dim in data.shape:
          if isinstance(dim, tvm.tir.Any):
              dshape.append(tvm.te.size_var("dim"))
          else:
              dshape.append(dim)
      out_shape = tuple(
          ana.simplify(dshape[i] + pad_before[i] + pad_after[i])
          for i in range(n)
      )
      pad_value = (
          pad_value
          if isinstance(pad_value, tvm.tir.PrimExpr)
          else tvm.tir.const(pad_value, data.dtype)
      )
  
      def _pad(*indices):
          not_zero = []
          index_tuple = []
          for i in range(n):
              if equal_const_int(pad_before[i], 0) and equal_const_int(
                  pad_after[i], 0
              ):
                  index_tuple.append(indices[i])
              else:
                  index_tuple.append(indices[i] - pad_before[i])
                  not_zero.append(indices[i] >= pad_before[i])
                  not_zero.append(
                      indices[i] < data.shape[i] + pad_before[i]
                  )
          if not_zero:
              not_zero = tvm.tir.all(*not_zero)
              return tvm.tir.if_then_else(
                  not_zero, data(*index_tuple), pad_value
              )
          return data(*index_tuple)
  
      return te.compute(out_shape, _pad, name=name, attrs=attrs)
  
imports: from __future__ import absolute_import
  import tvm
  from tvm import te
  from ..None import tag
  from ..utils import equal_const_int
label_desc: Use image node_id 1 for calling a global function with example usage: pad(data, pad_before, pad_after, pad_value, name, attrs) and returns: te, data, tvm