// ip rule add fwmark 0x111/0xfff pref 32764 lookup 100
		//
		// Adds in-pod rules for marking packets with the istio-specific TPROXY mark.
		// A very similar mechanism is used for sidecar TPROXY.
		//
		// TODO largely identical/copied from tools/istio-iptables/pkg/capture/run_linux.go
		inpodMarkRule := netlink.NewRule()
		inpodMarkRule.Family = family
		inpodMarkRule.Table = RouteTableInbound
		inpodMarkRule.Mark = InpodTProxyMark

	if err != nil {
		return false, fmt.Errorf("could not read %q: %v", profileB, err)
	}

	diff := util.YAMLDiff(a, b)
	if diff == "" {
		fmt.Fprintln(writer, "Profiles are identical")
	} else {
		fmt.Fprintf(writer, "The difference between profiles:\n%s", diff)
		return true, nil
	}

	return false, nil

			lhs:   UnstructuredToVal([]interface{}{"a", "b"}, &setListSchema),
			rhs:   UnstructuredToVal([]interface{}{"a", "b", "c"}, &setListSchema),
			equal: false,
		},
		{
			name:  "identical atomic lists are equal",
			lhs:   UnstructuredToVal([]interface{}{"a", "b"}, &atomicListSchema),
			rhs:   UnstructuredToVal([]interface{}{"a", "b"}, &atomicListSchema),
			equal: true,
		},
		{

func ExampleFloat_Copy() {
	var x, z big.Float

	x.SetFloat64(1.23)
	r := z.Copy(&x)
	fmt.Printf("a) r = %g, z = %g, x = %g, r == z = %v\n", r, &z, &x, r == &z)

	// changing z changes r since they are identical
	z.SetInt64(42)
	fmt.Printf("b) r = %g, z = %g, r == z = %v\n", r, &z, r == &z)

	x.SetPrec(1)
	z.Copy(&x)
	fmt.Printf("c) z = %g, x = %g, z == x = %v\n", &z, &x, &z == &x)

	// Output:

		return f(nil)
	}
	for _, t := range s.terms {
		assert(t.typ != nil)
		// x == under(x) for ~x terms
		u := t.typ
		if !t.tilde {
			u = under(u)
		}
		if debug {
			assert(Identical(u, under(u)))
		}
		if !f(u) {
			return false
		}
	}
	return true
}

// topTypeSet may be used as type set for the empty interface.
var topTypeSet = _TypeSet{terms: allTermlist}

				// x and y should be invalid now, but be conservative
				// and check below
			}
		}
		if x.mode == invalid || y.mode == invalid {
			return
		}

		// both argument types must be identical
		if !Identical(x.typ, y.typ) {
			check.errorf(x, InvalidComplex, invalidOp+"%v (mismatched types %s and %s)", call, x.typ, y.typ)
			return
		}

		// the argument types must be of floating-point type

// SameFile reports whether fi1 and fi2 describe the same file.
// For example, on Unix this means that the device and inode fields
// of the two underlying structures are identical; on other systems
// the decision may be based on the path names.
// SameFile only applies to results returned by this package's [Stat].
// It returns false in other cases.
func SameFile(fi1, fi2 FileInfo) bool {

// corresponding object, and that object's type is the (possibly generic) Named
// type. Declared Named types are identical if and only if their pointers are
// identical. On the other hand, multiple instantiated Named types may be
// identical even though their pointers are not identical. One has to use
// Identical to compare them. For instantiated named types, their obj is a
// synthetic placeholder that records their position of the corresponding

import org.gradle.test.fixtures.file.TestFile
import org.gradle.util.internal.TextUtil

abstract class AbstractModule implements Module {
    /**
     Last modified date for writeZipped to be able to create zipFiles with identical hashes
     */
    private static Date lmd = new Date(ZipCopyAction.CONSTANT_TIME_FOR_ZIP_ENTRIES)

    private boolean hasModuleMetadata
    private Closure<?> onEveryFile

    Map<String, String> attributes = [:]

		// CBOR supports distinct types for IEEE-754 float16, float32, and float64. Store
		// floats in the smallest width that preserves value so that equivalent float32 and
		// float64 values encode to identical bytes, as they do in a JSON
		// encoding. Satisfies one of the "Core Deterministic Encoding Requirements".
		ShortestFloat: cbor.ShortestFloat16,

		// ShortestFloat doesn't apply to NaN or Inf values. Inf values are losslessly