code: def _convert_lstm(
      inexpr, keras_layer, etab, data_layout, input_shape=None
  ):  # pylint: disable=unused-argument
      _check_data_format(keras_layer)
      if input_shape is None:
          input_shape = keras_layer.input_shape
      if not isinstance(inexpr, list):
          buf = np.zeros((1, keras_layer.units), "float32")
          c_op = etab.new_const(buf)
          h_op = etab.new_const(buf)
          inexpr = [inexpr, h_op, c_op]
      in_data = inexpr[0]
      next_h = inexpr[1]
      next_c = inexpr[2]
      weightList = keras_layer.get_weights()
      in_shape = tuple(
          dim if dim else 1 for dim in _as_list(input_shape)[0]
      )
      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"
      time_steps = in_shape[1]
      in_data = _op.squeeze(in_data, axis=[0])
      in_data = _op.split(
          in_data, indices_or_sections=time_steps, axis=0
      )
      # loop for the number of time_steps
      out_list = []  # store h outputs in case return_sequences is True
      for data in in_data:
          ixh1 = _op.nn.dense(data, kernel_weight, units=units)
          ixh2 = _op.nn.dense(next_h, recurrent_weight, units=units)
          if keras_layer.use_bias:
              ixh2 = _op.nn.bias_add(ixh2, bias=in_bias)
          gate = ixh1 + ixh2
          gates = _op.split(gate, indices_or_sections=4, axis=1)
          in_gate = _convert_recurrent_activation(gates[0], keras_layer)
          in_transform = _convert_recurrent_activation(
              gates[1], keras_layer
          )
          next_c = (
              in_transform * next_c
              + in_gate
              * _convert_activation(
                  gates[2], keras_layer, etab, data_layout
              )
          )
          out_gate = _convert_recurrent_activation(
              gates[3], keras_layer
          )
          next_h = out_gate * _convert_activation(
              next_c, keras_layer, etab, data_layout
          )
          if keras_layer.return_sequences:
              out_list.append(_op.expand_dims(next_h, axis=1))
      out = (
          _op.concatenate(out_list, axis=1)
          if keras_layer.return_sequences
          else next_h
      )
      out_shape = tuple(
          dim if dim else 1
          for dim in _as_list(keras_layer.output_shape)[0]
      )
      out = _op.reshape(out, newshape=out_shape)
      return [out, next_h, next_c]
  
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 28 for calling a global function with example usage: _convert_lstm(inexpr, keras_layer, etab, data_layout, input_shape) and returns: list