def METHOD_NAME(num_hidden, batch_size=1, dtype="float32", name=""):
    """Long-Short Term Memory (LSTM) network cell.
    Parameters
    ----------
    num_hidden : int
        Number of units in output symbol.
    batch_size : int
        Batch size (length of states).
    Returns
    -------
    result : tvm.relay.Function
        A Relay function that evaluates an LSTM cell.
        The function takes in a tensor of input data, a tuple of two
        states, and weights and biases for dense operations on the
        inputs and on the state. It returns a tuple with two members,
        an output tensor and a tuple of two new states.
    """
    builder = relay.ScopeBuilder()
    input_type = relay.TensorType((batch_size, num_hidden), dtype)
    weight_type = relay.TensorType((4 * num_hidden, num_hidden), dtype)
    bias_type = relay.TensorType((4 * num_hidden,), dtype)
    dense_type = relay.TensorType((batch_size, 4 * num_hidden), dtype)
    slice_type = relay.TupleType([input_type, input_type, input_type, input_type])
    ret_type = relay.TupleType([input_type, relay.TupleType([input_type, input_type])])
    inputs = relay.Var("inputs", input_type)
    states = relay.Var("states", relay.TupleType([input_type, input_type]))
    i2h_weight = relay.Var("i2h_weight", weight_type)
    i2h_bias = relay.Var("i2h_bias", bias_type)
    h2h_weight = relay.Var("h2h_weight", weight_type)
    h2h_bias = relay.Var("h2h_bias", bias_type)
    i2h = builder.let(
        ("i2h", dense_type),
        layers.dense_add_bias(
            data=inputs, units=num_hidden * 4, weight=i2h_weight, bias=i2h_bias, name=f"{name}i2h"
        ),
    )
    h2h = builder.let(
        ("h2h", dense_type),
        layers.dense_add_bias(
            data=relay.TupleGetItem(states, 0),
            units=num_hidden * 4,
            weight=h2h_weight,
            bias=h2h_bias,
            name=f"{name}h2h",
        ),
    )
    gates = builder.let(("gates", dense_type), relay.add(i2h, h2h))
    slice_gates = builder.let(
        ("slice_gates", slice_type), relay.split(gates, indices_or_sections=4, axis=1).astuple()
    )
    in_gate = builder.let(
        ("in_gate", input_type), relay.sigmoid(relay.TupleGetItem(slice_gates, 0))
    )
    forget_gate = builder.let(
        ("forget_gate", input_type), relay.sigmoid(relay.TupleGetItem(slice_gates, 1))
    )
    in_transform = builder.let(
        ("in_transform", input_type), relay.tanh(relay.TupleGetItem(slice_gates, 2))
    )
    out_gate = builder.let(
        ("out_gate", input_type), relay.sigmoid(relay.TupleGetItem(slice_gates, 3))
    )
    next_c = builder.let(
        ("next_c", input_type),
        relay.add(
            relay.multiply(forget_gate, relay.TupleGetItem(states, 1)),
            relay.multiply(in_gate, in_transform),
        ),
    )
    next_h = builder.let(("next_h", input_type), relay.multiply(out_gate, relay.tanh(next_c)))
    ret = builder.let(("ret", ret_type), relay.Tuple([next_h, relay.Tuple([next_h, next_c])]))
    builder.ret(ret)
    body = builder.get()
    return relay.Function(
        [inputs, states, i2h_weight, i2h_bias, h2h_weight, h2h_bias], body, ret_type
    )