if needSwap && (size != 1 || !root.Block.Func.Config.haveByteSwap(n)) {
		return false
	}

	// This is the commit point.

	// First, issue load at lowest address.
	v = loadBlock.NewValue2(pos, OpLoad, sizeType(n*size), r[0].load.Args[0], mem)

	// Byte swap if needed,
	if needSwap {
		v = byteSwap(loadBlock, pos, v)
	}

	// Extend if needed.
	if n*size < root.Type.Size() {

}

Value ReshapeScalarToSizeType(OpBuilder builder, Value scalar, Location loc) {
  auto size_type = GetSizeType(builder);
  return builder.create<TF::ReshapeOp>(
      loc, ArrayRef<Type>{size_type},
      ArrayRef<Value>{scalar, GetR1Const(size_type.getShape(), builder, loc)});
}

LogicalResult CreateInitBufferValue(ArrayRef<int64_t> element_shape,

  if (!begin_type || !begin_type.hasStaticShape()) return failure();

  auto size = slice_op.getSize();
  auto size_type = mlir::dyn_cast_or_null<RankedTensorType>(size.getType());
  if (!size_type || !size_type.hasStaticShape()) return failure();

  auto output_type =
      mlir::dyn_cast_or_null<RankedTensorType>(slice_op.getType());

  void runOnOperation() final;
};

// Returns the type of the local variable for the stack size.
Type GetSizeVarType(OpBuilder builder) {
  auto size_type = cutil::GetSizeType(builder);
  return RankedTensorType::get(
      {}, TF::ResourceType::get(ArrayRef<TensorType>{size_type},
                                builder.getContext()));
}

// Returns the aliasing argument number of a fucntion return value if it simply

struct SizeInfo {
  Value size;
  bool fixed;
};

// Modifies a function's signature to rewrite tensor list arguments to buffers
// and sizes.
void ModifyFunctionSignature(
    func::FuncOp func, Type size_type,
    llvm::SmallDenseMap<Value, SizeInfo>* buffer_to_size,
    llvm::function_ref<std::optional<Type>(int64_t)> arg_to_buffer_type,
    llvm::function_ref<bool(int64_t)> arg_buffer_size_is_fixed) {

        slice_op.setOperand(1, new_begin);
        return success();
      }
    }

    // Handle size.
    if (size_op && size_type && size_type.getElementType().isInteger(64)) {
      auto new_size = NarrowDownInt64InputValuesForOp(
          size_op, size_type, slice_op.getLoc(), &rewriter);
      if (new_size != nullptr) {
        slice_op.setOperand(2, new_size);
        return success();
      }

                                                 lower_limit_cst);

    SmallVector<int64_t> size_len{rank};
    TensorType size_type = operand_type.cloneWith(size_len, i64_type);
    auto size_attr = DenseIntElementsAttr::get(size_type, slice_sizes);
    auto size = rewriter.create<arith::ConstantOp>(op.getLoc(), size_attr);

    rewriter.replaceOpWithNewOp<TFL::SliceOp>(op, output, input, begin, size);

    auto begin_type = mlir::dyn_cast<RankedTensorType>(begin_indices.getType());
    auto size_type = mlir::dyn_cast<RankedTensorType>(sizes.getType());

    if (!input_ty || !begin_type || !size_type ||
        !begin_type.hasStaticShape() || !size_type.hasStaticShape() ||
        begin_type.getRank() != 1 || size_type.getRank() != 1) {
      return failure();
    }

    func::FuncOp ret = queue_.front();
    queue_.pop();
    queue_set_.erase(ret);
    return ret;
  }

  // Returns the current size of the queue.
  std::queue<func::FuncOp>::size_type QueueSize() const {
    return queue_.size();
  }

  Dialect* const tf_dialect_;

 private:
  // Returns whether the result of an operation could be updated to a new