code: def _convert_gru(
      inexpr, keras_layer, etab, data_layout, input_shape=None
  ):  # pylint: disable=unused-argument
      _check_data_format(keras_layer)
      if not isinstance(inexpr, list):
          buf = np.zeros((1, keras_layer.units), "float32")
          h_tm1 = etab.new_const(buf)
          inexpr = [inexpr, h_tm1]
      in_data = inexpr[0]
      h_tm1_op = inexpr[1]
      weightList = keras_layer.get_weights()
      kernel_weight = etab.new_const(weightList[0].transpose([1, 0]))
      recurrent_weight = etab.new_const(weightList[1].transpose([1, 0]))
      if keras_layer.use_bias:
          in_bias = etab.new_const(weightList[2])
      if keras_layer.go_backwards:
          in_data = _op.reverse(in_data, axis=1)
      units = list(weightList[0].shape)[1]
      assert units > 0, "The value of units must be a positive integer"
      in_data = _op.nn.batch_flatten(in_data)
      matrix_x = _op.nn.dense(in_data, kernel_weight, units=units)
      if keras_layer.use_bias:
          matrix_x = _op.nn.bias_add(matrix_x, in_bias)
      # inputs projected by all gate matrices at once
      split_indices = [keras_layer.units, 2 * keras_layer.units]
      gates = _op.split(
          matrix_x, indices_or_sections=split_indices, axis=1
      )
      x_z = gates[0]
      x_r = gates[1]
      x_h = gates[2]
      # hidden state projected separately for update/reset and new
      units = 2 * keras_layer.units
      split_indices = [units]
      rec_weights = _op.split(
          recurrent_weight, indices_or_sections=split_indices, axis=0
      )
      h_tm1_op = _op.nn.batch_flatten(h_tm1_op)
      matrix_inner = _op.nn.dense(h_tm1_op, rec_weights[0], units=units)
      split_indices = [keras_layer.units]
      recurrent = _op.split(
          matrix_inner, indices_or_sections=split_indices, axis=1
      )
      recurrent_z = recurrent[0]
      recurrent_r = recurrent[1]
      rec_act_z = _convert_recurrent_activation(
          x_z + recurrent_z, keras_layer
      )
      rec_act_r = _convert_recurrent_activation(
          x_r + recurrent_r, keras_layer
      )
      units = keras_layer.units
      recurrent_h = _op.nn.dense(
          rec_act_r * h_tm1_op, rec_weights[1], units=units
      )
      act_hh = _convert_activation(
          x_h + recurrent_h, keras_layer, etab, data_layout
      )
      # previous and candidate state mixed by update gate
      output = (
          rec_act_z * h_tm1_op
          + (_expr.const(1.0, dtype="float32") - rec_act_z) * act_hh
      )
      out_shape = tuple(
          dim if dim else 1
          for dim in _as_list(keras_layer.output_shape)[0]
      )
      output = _op.reshape(output, newshape=out_shape)
      return [output, output]
  
imports: import dis
  import sys
  import numpy
  import tvm
  from tvm.ir import IRModule, TensorType, TupleType
  from ..None import analysis
  from ..None import expr
  from ..None import function
  from ..None import op
  from ...None import nd
  from .common import ExprTable, new_var
label_desc: Use image node_id 30 for calling a global function with example usage: _convert_gru(inexpr, keras_layer, etab, data_layout, input_shape) and returns: list