{oid: OID{}, oid2: OID{}, eq: true},
		{oid: OID{}, oid2: mustNewOIDFromInts(t, []uint64{2, 33, 23}), eq: false},
	}

	for _, tt := range cases {
		if eq := tt.oid.Equal(tt.oid2); eq != tt.eq {
			t.Errorf("(%v).Equal(%v) = %v, want %v", tt.oid, tt.oid2, eq, tt.eq)
		}
	}
}

var (
	_ encoding.BinaryMarshaler   = OID{}

		return f
	}

	missingBinaries := false
	mappingLocs := map[*profile.Mapping][]*profile.Location{}
	for _, l := range prof.Location {
		mappingLocs[l.Mapping] = append(mappingLocs[l.Mapping], l)
	}
	for midx, m := range prof.Mapping {
		locs := mappingLocs[m]
		if len(locs) == 0 {
			// The mapping is dangling and has no locations pointing to it.
			continue
		}

    CALIBRATION_METHOD_HISTOGRAM_PERCENTILE = 3;
    // Use the histogram mid values that minimize MSE error.
    // This is very slow algorithm because it computes all errors for all
    // histogram mid value pairs. Therefore the value of num_bins is recommended
    // to be 256 or less.
    CALIBRATION_METHOD_HISTOGRAM_MSE_BRUTEFORCE = 4;
    // Use the histogram mid values that minimize MSE error.

	var exit2Called bool
	var errCode2 int
	exitFn2 := func(errCode int) {
		exit2Called = true
		errCode2 = errCode
	}

	s := newTestSuite("tid1", runFn1, exitFn1, defaultSettingsFn)

	s2 := newTestSuite("tid2", runFn2, exitFn2, defaultSettingsFn)

	go s.Run()
	waitForRun1.Wait()

	s2.Run()
	waitForTestCompletion.Done()
	waitForExit1Call.Wait()

	g.Expect(exit2Called).To(Equal(true))

		ts, err := binary.ReadUvarint(r)
		if err != nil {
			return nil, err
		}

		// Read the sample's M.
		m, err := binary.ReadUvarint(r)
		if err != nil {
			return nil, err
		}
		mid := ThreadID(m)

		// Read the sample's P.
		p, err := binary.ReadUvarint(r)
		if err != nil {
			return nil, err
		}
		pid := ProcID(p)

		// Read the sample's G.
		g, err := binary.ReadUvarint(r)

	// this here and not e.g. on the trace reader.
	traceFrequency(gen)

	// Collect all the untraced Gs.
	type untracedG struct {
		gp           *g
		goid         uint64
		mid          int64
		stackID      uint64
		status       uint32
		waitreason   waitReason
		inMarkAssist bool
	}
	var untracedGs []untracedG
	forEachGRace(func(gp *g) {

		_ = min(1)
		_ = min(1, 2.3, 'a')
		_ = min(1, "foo" /* ERROR "mismatched types" */ )
		_ = min(1, 0i /* ERROR "cannot be ordered" */ )
		_ = min(1, 2 /* ERROR "cannot be ordered" */ + 3i )
	)
}

func min2() {
	_ = assert(min(0) == 0)
	_ = assert(min(0, 1) == 0)
	_ = assert(min(0, -10, 123456789) == -10)
	_ = assert(min(-12345678901234567890, 0) == -12345678901234567890)

	_ = assert(min(1, 2.3) == 1)