*/
    public static VirtualComponentIdentifier makeVirtual(final ComponentIdentifier id) {
        ModuleComponentIdentifier mid = assertModuleComponentIdentifier(id);
        return new DefaultVirtualModuleComponentIdentifier(mid.getModuleIdentifier(), mid.getVersion());
    }

    private static ModuleComponentIdentifier assertModuleComponentIdentifier(ComponentIdentifier id) {

)

type rtprio struct {
	_type uint16
	prio  uint16
}

type lwpparams struct {
	start_func uintptr
	arg        unsafe.Pointer
	stack      uintptr
	tid1       unsafe.Pointer // *int32
	tid2       unsafe.Pointer // *int32
}

type sigset struct {
	__bits [4]uint32
}

type stackt struct {
	ss_sp     uintptr
	ss_size   uintptr
	ss_flags  int32
	pad_cgo_0 [4]byte
}

		// In fact, the bottom bit of mid won't
		// make it into the mantissa either.
		// We only need to make sure that if top+mid
		// is about to round down in a round-to-even
		// scenario, and bot is not zero, we make it
		// round up instead.
		mid |= 1
	}
	return float32(top)*(1<<46) + float32(mid)*(1<<23)
}

func _d2v(y *uint64, d float64) {
	x := *(*uint64)(unsafe.Pointer(&d))

	xhi := uint32(x>>32)&0xfffff | 0x100000

//    Rule: Never break between consecutive runes of this category.
//
// 2) Mid:
//    MidLetter, MidNumLet, Single_Quote.
//    (Cf. case-ignorable: MidLetter, MidNumLet, Single_Quote or cat is Mn,
//    Me, Cf, Lm or Sk).
//    Rule: Don't break between Letter and Mid, but break between two Mids.
//
// 3) Break:
//    Any other category: NewLine, MidNum, CR, LF, Double_Quote, Katakana, and
//    Other.

# go clean -modcache can delete read-only dependencies
go clean -modcache
! exists $GOPATH/pkg/mod/rsc.io/quote@v1.5.2

# list {{.Dir}} shows replaced directories
cp go.mod2 go.mod
go list -mod=mod -f {{.Dir}} rsc.io/quote
go list -m -f '{{.Path}} {{.Version}} {{.Dir}}{{with .Replace}} {{.GoMod}} => {{.Version}} {{.Dir}} {{.GoMod}}{{end}}' all
stdout 'mod[\\/]rsc.io[\\/]quote@v1.5.1'

        return (id1, id2) -> {
            // Root is always last
            if (id1.equals(DefaultBuildIdentifier.ROOT)) {
                if (id2.equals(DefaultBuildIdentifier.ROOT)) {
                    return 0;
                } else {
                    return 1;
                }
            }
            if (id2.equals(DefaultBuildIdentifier.ROOT)) {
                return -1;

        out.selectedVariant == 123L
    }

    def "serializes failed dependency result"() {
        def mid = DefaultModuleIdentifier.newId("x", "y")
        def requested = DefaultModuleComponentSelector.newSelector(mid, new DefaultMutableVersionConstraint("1.0"))
        def failure = new ModuleVersionResolveException(newSelector(mid, "1.2"), new RuntimeException("Boo!"))

        def failed = Mock(DependencyGraphEdge) {

            Mock(LocalConfigurationGraphResolveMetadata)
        }
    }

    def configurationsProvider = Stub(ConfigurationsProvider)
    ProjectStateRegistry projectStateRegistry = Mock()

    def mid = DefaultModuleIdentifier.newId('foo', 'bar')

    def builderFactory = new DefaultRootComponentMetadataBuilder.Factory(
        metaDataProvider,
        componentIdentifierFactory,
        moduleIdentifierFactory,

    /*
     * We want each multiplication to have both sides with approximately the same number of digits.
     * Currently, we just divide the range in half.
     */
    int mid = (n1 + n2) >>> 1;
    return oldSlowFactorial(n1, mid).multiply(oldSlowFactorial(mid, n2));
  }

  @Benchmark
  int slowFactorial(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;

        UserCodeApplicationId id2 = null
        List<UserCodeApplicationId> ids = []
        userCodeApplicationContext.apply(Stub(UserCodeSource)) {
            id1 = it
            container.register("a") {
                ids << userCodeApplicationContext.current()
            }
        }
        userCodeApplicationContext.apply(Stub(UserCodeSource)) {
            id2 = it
            container.named("a").configure {