LC_VERSION_NOTE, LC_BUILD_VERSION:
			// Nothing to update
		default:
			err = fmt.Errorf("unknown load command 0x%x (%s)", int(cmd.Cmd), cmd.Cmd)
		}
		if err != nil {
			return err
		}
	}
	// Do the final update of the DWARF segment's load command.
	return machoUpdateDwarfHeader(&reader, compressedSects, dwarfsize, dwarfstart, realdwarf)
}

// subtracted from the total CPU time in the next update.
func (l *gcCPULimiterState) addIdleTime(t int64) {
	l.idleTimePool.Add(t)
}

// update updates the bucket given runtime-specific information. now is the
// current monotonic time in nanoseconds.
//
// This is safe to call concurrently with other operations, except *GCTransition.
func (l *gcCPULimiterState) update(now int64) {
	if !l.tryLock() {

	}
	// When comparing the subsets, we ignore the difference in ResourceVersion of Pod to avoid unnecessary Endpoints
	// updates caused by Pod updates that we don't care, e.g. annotation update.
	if !createEndpoints &&
		endpointSubsetsEqualIgnoreResourceVersion(currentEndpoints.Subsets, subsets) &&
		apiequality.Semantic.DeepEqual(compareLabels, service.Labels) &&

//  3. Copy new RS's revision number to deployment (update deployment's revision). If this step failed, we'll update it in the next deployment sync loop.
//
// Note that currently the deployment controller is using caches to avoid querying the server for reads.
// This may lead to stale reads of replica sets, thus incorrect deployment status.

//===----------------------------------------------------------------------===//

def LowerTensorScatterAdd: Pat<
  (TF_TensorScatterAddOp $input, $indices, $updates),
  (TF_TensorScatterUpdateOp $input, $indices,
     (TF_AddOp $updates, (CreateGatherNdOp $updates, $input, $indices)))>;

//===----------------------------------------------------------------------===//
// AddV2 op patterns.

				}
				if updateGot {
					t.Errorf("Expected update=%t but got: %t", false, updateGot)
				}
				return
			}

			if !updateGot {
				t.Errorf("Expected update=%t but got: %t", true, updateGot)
			}
			if !reflect.DeepEqual(test.newObjectExpected, updatableGot) {
				t.Errorf("Expected the object to be updated to match - diff: %s", cmp.Diff(test.newObjectExpected, updatableGot))
			}
		})

					case <-ctx.Done():
					}
				}
				break
			}

			if loggerV := logger.V(6); loggerV.Enabled() {
				loggerV.Info("Driver resources updated", "resources", response.Resources)
			} else {
				logger.V(5).Info("Driver resources updated", "numResources", len(response.Resources))
			}

			c.mutex.Lock()
			active.resources = response.Resources
			c.mutex.Unlock()
			c.queue.Add(driverName)
		}

	}

	antiTerms, err := framework.GetAffinityTerms(pod, framework.GetPodAntiAffinityTerms(pod.Spec.Affinity))
	if err != nil {
		return framework.Queue, err
	}

	// Pod is updated. Return Queue when the updated pod matching the target pod's affinity or not matching anti-affinity.
	// Note that, we don't need to check each affinity individually when the Pod has more than one affinity

	// The topology cache should be updated in this case.
	if isNodeReady(oldNode) != isNodeReady(curNode) ||
		oldNode.Labels[v1.LabelTopologyZone] != curNode.Labels[v1.LabelTopologyZone] {
		c.topologyQueue.Add(topologyQueueItemKey)
	}
}

func (c *Controller) deleteNode() {
	c.topologyQueue.Add(topologyQueueItemKey)
}

// checkNodeTopologyDistribution updates Nodes in the topology cache and then

				// We are only interested in observing updates to quota.spec to drive updates to quota.status.
				// We ignore all updates to quota.Status because they are all driven by this controller.
				// IMPORTANT:
				// We do not use this function to queue up a full quota recalculation.  To do so, would require
				// us to enqueue all quota.Status updates, and since quota.Status updates involve additional queries