Output var_handle = ops::VarHandleOp(scope.WithOpName("Var_" + id), DT_FLOAT,
                                       TensorShape({}));
  ops::AssignVariableOp assign_op(scope.WithOpName("Assignee_" + id),
                                  var_handle, value_to_write);
  return assign_op.operation.node();
}

Node* MakeWrite(const Scope& scope, const string& id) {
  return MakeWrite(

	// yet.
	// TODO(gri) Need to systematically review all uses of type parameter
	//           constraints to make sure we don't rely on them if they
	//           are not properly set yet.
	for _, name := range names {
		tname := NewTypeName(name.Pos(), check.pkg, name.Name, nil)
		tpar := check.newTypeParam(tname, Typ[Invalid]) // assigns type to tpar as a side-effect

     * <p>
     * If no credentials have been assigned to this repository, an empty set of credentials of the specified type is assigned to this repository and returned.
     *
     * @param credentialsType type of the credential
     * @return The credentials
     * @throws IllegalArgumentException when the credentials assigned to this repository are not assignable to the specified type
     */

                val assigned = objectReflection.properties.getValue(property)
                applyPropertyValue(objectReflection.objectOrigin, property, assigned)
                apply(assigned.value, conversionFilter)
                // TODO: record properties assigned in function calls or constructors, so that
                //       we can check that all properties were assigned
            }

  ImmediateOpPtr assign_op(ctx->CreateOperation());
  TF_RETURN_IF_ERROR(assign_op->Reset("AssignVariableOp", nullptr));
  TF_RETURN_IF_ERROR(assign_op->SetAttrType("dtype", dtype));
  TF_RETURN_IF_ERROR(assign_op->AddInput(variable_handle));
  TF_RETURN_IF_ERROR(assign_op->AddInput(value));

  int num_retvals = 0;
  TF_RETURN_IF_ERROR(assign_op->Execute({}, &num_retvals));
  return Status();
}

package v1

// NodeConfigStatusApplyConfiguration represents an declarative configuration of the NodeConfigStatus type for use
// with apply.
type NodeConfigStatusApplyConfiguration struct {
	Assigned      *NodeConfigSourceApplyConfiguration `json:"assigned,omitempty"`
	Active        *NodeConfigSourceApplyConfiguration `json:"active,omitempty"`
	LastKnownGood *NodeConfigSourceApplyConfiguration `json:"lastKnownGood,omitempty"`

type CPUsProvider interface {
	// GetCPUs returns information about the cpus assigned to pods and containers
	GetCPUs(podUID, containerName string) []int64
	// GetAllocatableCPUs returns the allocatable (not allocated) CPUs
	GetAllocatableCPUs() []int64
}

type MemoryProvider interface {
	// GetMemory returns information about the memory assigned to containers
	GetMemory(podUID, containerName string) []*podresourcesapi.ContainerMemory

  // Inherit the constructors.
  using OpRewritePattern<TF::AssignVariableOp>::OpRewritePattern;

  LogicalResult match(TF::AssignVariableOp assign_op) const override {
    Value resource_operand = assign_op.getOperand(0);
    Value assigned_value_operand = assign_op.getOperand(1);

    if (isa<TF::VarHandleOp>(resource_operand.getDefiningOp()) &&
        isa<TF::ConstOp>(assigned_value_operand.getDefiningOp())) {

        val (rhs1, rhs2) = rhsOrigins

        with(rhs1.assigned) {
            assertIs<ObjectOrigin.NewObjectFromMemberFunction>(this)
            assertEquals("my1", function.simpleName)
        }

        with(rhs2.assigned) {
            assertIs<ObjectOrigin.NewObjectFromMemberFunction>(this)
            assertEquals("my2", function.simpleName)
        }

		"service will be of type ClusterIP.")

	fs.StringVar(&s.ServiceClusterIPRanges, "service-cluster-ip-range", s.ServiceClusterIPRanges, ""+
		"A CIDR notation IP range from which to assign service cluster IPs. This must not "+
		"overlap with any IP ranges assigned to nodes or pods. Max of two dual-stack CIDRs is allowed.")

	fs.Var(&s.ServiceNodePortRange, "service-node-port-range", ""+