// its memory argument is live. We can't just put it in root.Block.
	// We use the block of the latest load.
	loads := make([]*Value, n, 8)
	for i := int64(0); i < n; i++ {
		loads[i] = r[i].load
	}
	loadBlock := mergePoint(root.Block, loads...)
	if loadBlock == nil {
		return false
	}
	// Find a source position to use.
	pos := src.NoXPos
	for _, load := range loads {
		if load.Block == loadBlock {
			pos = load.Pos

		return 8
	case align%4 == 0:
		return 4
	case align%2 == 0:
		return 2
	}
	return 1
}

// mergePoint finds a block among a's blocks which dominates b and is itself
// dominated by all of a's blocks. Returns nil if it can't find one.
// Might return nil even if one does exist.
func mergePoint(b *Block, a ...*Value) *Block {
	// Walk backward from b looking for one of the a's blocks.

	// Max distance
	d := 100

		// of them encode unpreferred allocations.
		mergedHint := mergePermutation(defaultAffinity, permutation)

		// Compare the current bestHint with the candidate mergedHint and
		// update bestHint if appropriate.
		bestHint = m.compare(bestHint, &mergedHint)
	})

	if bestHint == nil {
		bestHint = &TopologyHint{defaultAffinity, false}
	}

    private final Object2IntMap<InstrumentableClosure> currentClosuresEntries = new Object2IntOpenHashMap<>();

    @Override
    public void enterClosure(InstrumentableClosure thisClosure) {
        currentClosuresEntries.mergeInt(thisClosure, 1, Integer::sum);
    }

    @Override
    public void leaveClosure(InstrumentableClosure thisClosure) {
        currentClosuresEntries.computeInt(thisClosure, (key, oldValue) -> {