getOperation().walk([](Operation* op) {
      if (auto tl_reserve = dyn_cast<TensorListReserveOp>(op)) {
        ReplicateTensorListForUses(tl_reserve);
      }
      if (auto tl_empty = dyn_cast<EmptyTensorListOp>(op)) {
        ReplicateTensorListForUses(tl_empty);
      }
    });
  }
};
}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>>
CreateReplicateTensorListInitOpsPass() {

    tflite::TensorType tflite_type =
        tflite::ConvertTypeToTensorType(reserve.getElementDtype());

    return CreateListReserveOptions(context, tflite_type);
  }
  if (auto empty = llvm::dyn_cast_or_null<mlir::TF::EmptyTensorListOp>(op)) {
    tflite::TensorType tflite_type =
        tflite::ConvertTypeToTensorType(empty.getElementDtype());

    return CreateListReserveOptions(context, tflite_type);
  }
  return {};
}

  if (!tensor_type.hasStaticShape()) return failure();
  for (auto d : tensor_type.getShape()) shape->push_back(d);
  return success();
}

LogicalResult HandleEmptyTensorListOp(
    TF::EmptyTensorListOp list,
    llvm::SmallDenseMap<Value, SizeInfo>* buffer_to_size) {
  Value buffer;
  OpBuilder builder(list);
  llvm::SmallVector<int64_t, 8> element_shape;

      CompileTimeConstantOperand<TF::DepthwiseConv2dNativeBackpropInputOp, 0>,
      CompileTimeConstantOperand<TF::EmptyOp, 0>,  // $shape
      // $element_shape, $max_num_elements
      CompileTimeConstantOperand<TF::EmptyTensorListOp, 0, 1>,
      CompileTimeConstantOperand<TF::ExpandDimsOp, 1>,   // $dim
      CompileTimeConstantOperand<TF::FillOp, 0>,         // $dims
      CompileTimeConstantOperand<TF::GatherV2Op, 2>,     // $axis

// any restrictions on the number of elements we can support. So this may
// have a different behavior compared to TensorFlow in case of errors.
struct ConvertEmptyTensorList
    : public ConvertTensorListInitOp<TF::EmptyTensorListOp> {
  explicit ConvertEmptyTensorList(MLIRContext *context,
                                  bool allow_tensorlist_pass_through,
                                  bool default_to_single_batch)

      GET_OPERATION_NAME(mlir::TF::TensorArrayGatherV3Op),
      GET_OPERATION_NAME(mlir::TF::TensorArrayScatterV3Op),
      // Tensor List Ops.
      GET_OPERATION_NAME(mlir::TF::EmptyTensorListOp),
      GET_OPERATION_NAME(mlir::TF::TensorListReserveOp),
      GET_OPERATION_NAME(mlir::TF::TensorListFromTensorOp),
      GET_OPERATION_NAME(mlir::TF::TensorListPushBackOp),

  }

  return {};
}

//===----------------------------------------------------------------------===//
// EmptyTensorListOp
//===----------------------------------------------------------------------===//

LogicalResult EmptyTensorListOp::verify() {
  EmptyTensorListOp op = *this;
  // This is required to populate derived attributes during export in a

bool IsTensorListInitOp(Operation* op) {
  return isa<TensorListReserveOp>(op) || isa<EmptyTensorListOp>(op) ||
         isa<TensorListFromTensorOp>(op);
}

// Returns the `element_shape` operand of the ops that create a TensorList.
Value GetElementShapeOperand(Operation* op) {
  if (auto empty_tl = dyn_cast<EmptyTensorListOp>(op))
    return empty_tl.getElementShape();
  if (auto tl_reserve = dyn_cast<TensorListReserveOp>(op))