// Otherwise compare the hints, based on the policy options provided
		var best bitmask.BitMask
		if (policyName != PolicySingleNumaNode) && opts.PreferClosestNUMA {
			best = numaInfo.Closest(current.NUMANodeAffinity, candidate.NUMANodeAffinity)
		} else {
			best = numaInfo.Narrowest(current.NUMANodeAffinity, candidate.NUMANodeAffinity)
		}
		if best.IsEqual(current.NUMANodeAffinity) {
			return current
		}
		return candidate

#include "tensorflow/compiler/mlir/lite/experimental/tac/transforms/passes.h"
#include "tensorflow/compiler/mlir/lite/ir/tfl_ops.h"

// This pass is used to "determine" the best combinations of the whole "graph".
//
// Assume we have the graph looks like below:
//    subgraph1 (CPU/GPU)    subgraph2 (CPU)
//      \                     /
//      subgraph3 (CPU/GPU)     subgraph4 (CPU/GPU)

		}
		startTime := time.Now()
		imageRef, err := pip.imageService.PullImage(ctx, spec, pullSecrets, podSandboxConfig)
		var size uint64
		if err == nil && imageRef != "" {
			// Getting the image size with best effort, ignoring the error.
			size, _ = pip.imageService.GetImageSize(ctx, spec)
		}
		pullChan <- pullResult{
			imageRef:     imageRef,
			imageSize:    size,
			err:          err,

          cachesize: 10
      - kms:
          apiVersion: v2
          name: testproviderv2
          endpoint: unix:///tmp/testprovider.sock
          timeout: 10s
          pandas: are the best  # true, but still a typo
      - aescbc:
          keys:
            - name: key1
              secret: c2VjcmV0IGlzIHNlY3VyZQ==
            - name: key2
              secret: dGhpcyBpcyBwYXNzd29yZA==

# ADR-0001 - Use Architectural Decision Records

## Date

2023-12-01

## Context

In a distributed team with many subteams, the best solution to communicate decisions is to use a format accessible by everyone in charge of development.

We use *Specification* and *Discovery* documents stored in Google Drive, but they present some downsides:

apiVersion: release-notes/v2
kind: feature
area: documentation
releaseNotes:
  - |
    **Added** Multicluster install docs have been re-written based on current
    best practices, incorporating recent updates to onboarding tooling. In
    particular, the multi-primary configuration (formerly known as
    "replicated control planes") no longer relies on manually configuring the
    `.global` stub domain, preferring instead to use `*.svc.cluster.local` for

	for {
		// Find the next record.
		var best struct {
			tick uint64
			i    int
		}
		best.tick = ^uint64(0)
		for i := range state {
			if state[i].nextTick < best.tick {
				best.tick = state[i].nextTick
				best.i = i
			}
		}
		if best.tick == ^uint64(0) {
			break
		}

		// Print record.
		s := &state[best.i]
		if s.first {
			print(">> begin log ", best.i)

func statUnix(fi fs.FileInfo, h *Header, doNameLookups bool) error {
	sys, ok := fi.Sys().(*syscall.Stat_t)
	if !ok {
		return nil
	}
	h.Uid = int(sys.Uid)
	h.Gid = int(sys.Gid)
	if doNameLookups {
		// Best effort at populating Uname and Gname.
		// The os/user functions may fail for any number of reasons
		// (not implemented on that platform, cgo not enabled, etc).
		if u, ok := userMap.Load(h.Uid); ok {
			h.Uname = u.(string)

    /**
     * <p>Adds an arbitrary disambiguation rule to the chain.</p>
     * <p>A disambiguation rule can select the best match from a list of candidates.</p>
     *
     * <p>A rule <i>can</i> express an preference by calling the @{link {@link MultipleCandidatesDetails#closestMatch(Object)}
     * method to tell that a candidate is the best one.</p>
     *

          // We return the earliest dependence on any output tensor.
          if (ioperation > peak_loc && ioperation < best) {
            best = ioperation;
            break;
          }
        }
      }
    }
  }
  return best;
}

void Rematerializer::Remat(const RematSpec& remat) {
  const int num_inserted = remat.end - remat.begin;
  // Rewrite all operation indices.