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);

    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