// make sure whole word is being compared,
	// not just a single byte.
	i = v.Field(4)
	j = v.Field(5)
	assert(i.Interface() != j.Interface())

	i = v.Field(6)
	j = v.Field(7)
	assert(i.Interface() != j.Interface())

	i = v.Field(8)
	j = v.Field(9)
	assert(i.Interface() == j.Interface())
}

/*
comparing uncomparable type float32
throw: interface compare

panic PC=0x28ceb8 [1]

    T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object> {
  /**
   * Creates a {@code CollectorTester} for the specified {@code Collector}. The result of the {@code
   * Collector} will be compared to the expected value using {@link Object#equals}.
   */
  public static <T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object>
      CollectorTester<T, A, R> of(Collector<T, A, R> collector) {

// bad backing store pointers but nonzero length, so we can check that
// the backing store never gets compared.
//
// We use two different bad strings so that pointer comparisons of
// backing store pointers fail.

package main

import (
	"fmt"
	"reflect"
	"syscall"
	"unsafe"
)

type SI struct {
	s string
	i int
}

type SS struct {
	s string
	t string
}

// For instance, I can make a transformation from `object => object.name` to only trigger events for changes to the name;
// the output will be compared (using standard equality checking), and only changes will trigger the handler.
// Note this is in addition to the normal event mechanics, so this can only filter things further.

	fuzz.Fuzz(f, func(fg fuzz.Helper) {
		r := fuzz.Struct[*networking.TrafficPolicy_PortTrafficPolicy](fg)

		// The port does not need to be copied.
		r.Port = nil

		// The type has changed and cannot be compared directly.
		// Convert to []byte for comparison.
		copied := shadowCopyPortTrafficPolicy(r)
		rjs, _ := json.Marshal(r)
		cjs, _ := json.Marshal(copied)
		assert.Equal(fg.T(), rjs, cjs)
	})
}

	BEQ	samebytes
	CMP	$4, R6
	ADD	R2, R6		// R2 is current byte in a, R6 is the end of the range to compare
	BLT	byte_loop	// length < 4
	AND	$3, R2, R8
	CMP	$0, R8
	BNE	byte_loop	// unaligned a, use byte-wise compare (TODO: try to align a)
aligned_a:
	AND	$3, R3, R8
	CMP	$0, R8
	BNE	byte_loop	// unaligned b, use byte-wise compare
	AND	$0xfffffffc, R6, R8
	// length >= 4
chunk4_loop:
	MOVW.P	4(R2), R4
	MOVW.P	4(R3), R5

// is std::nullopt, all signatures will be imported. Otherwise, only names
// in `exported_names` are imported.
//
// Note that the word `Lite` means it is a lighter version compared to
// ConvertSavedModelV1ToMlir(), and is not related to TFLite.
//
// TODO(b/179683149): Rename this class to avoid confusion with TFLite.
absl::StatusOr<mlir::OwningOpRef<mlir::ModuleOp>> ConvertSavedModelV1ToMlirLite(

	"name":                     "name...

    fi
done < <(find_files | sed 's|/.readonly||')

if [ ${#conflicts[@]} -gt 0 ]; then
    exec 1>&2
    for dir in "${conflicts[@]}"; do
        echo "Found ${dir}/.readonly, but files changed compared to \"${branch}\" branch."
    done
    exit 1
else
    echo "Readonly packages verified."
fi

// Kubernetes, as specified in requests and limits, describing each pod in the
// current scale target (e.g. CPU or memory).  The values will be averaged
// together before being compared to the target.  Such metrics are built in to
// Kubernetes, and have special scaling options on top of those available to
// normal per-pod metrics using the "pods" source.  Only one "target" type
// should be set.