iprHasModules "buildA.iml",
            "../buildB/buildB.iml",
            "../buildB/b1/buildB-b1.iml",
            "../buildB/b2/b2.iml",
            "../buildC/buildC.iml",
            "../buildC/b1/buildC-b1.iml",
            "../b1/buildA-b1.iml"

        imlHasDependencies "buildB-b1", "buildC-b1", "buildA-b1"
    }

    @ToBeFixedForConfigurationCache

	// Karatsuba pre-computation
	VEXT	$8, B0.B16, B0.B16, B1.B16
	VEOR	B0.B16, B1.B16, B1.B16

	ADD	$14*16, pTbl
	VST1	[B0.B16, B1.B16], (pTbl)
	SUB	$2*16, pTbl

	VMOV	B0.B16, B2.B16
	VMOV	B1.B16, B3.B16

	MOVD	$7, I

initLoop:
	// Compute powers of H
	SUBS	$1, I

	VPMULL	B0.D1, B2.D1, T1.Q1
	VPMULL2	B0.D2, B2.D2, T0.Q1
	VPMULL	B1.D1, B3.D1, T2.Q1
	VEOR	T0.B16, T2.B16, T2.B16

        def dir1 = tmpDir.createDir("b1")
        def dir2 = tmpDir.createDir("other/b1")
        def dir3 = tmpDir.createDir("other2/b1")
        def buildDefinition1 = build(dir1, "b1")
        def buildDefinition2 = build(dir2, "b2")
        def buildDefinition3 = build(dir3, "b3")
        def includedBuild1 = expectIncludedBuildAdded("b1", buildDefinition1)

			break
		}

		// Walk over attributes, counting.
		n := 0
		b1 := b // Read from copy of b.
		b1.uint()
		b1.uint8()
		for {
			tag := b1.uint()
			fmt := b1.uint()
			if tag == 0 && fmt == 0 {
				break
			}
			if format(fmt) == formImplicitConst {
				b1.int()
			}
			n++
		}
		if b1.err != nil {
			return nil, b1.err
		}

		// Walk over attributes again, this time writing them down.

	MOVOU B0, (16*14)(dst)
	PSHUFD $78, B0, B1
	PXOR B0, B1
	MOVOU B1, (16*15)(dst)

	MOVOU B0, B2
	MOVOU B1, B3
	// Now prepare powers of H and pre-computations for them
	MOVQ $7, AX

initLoop:
		MOVOU B2, T0
		MOVOU B2, T1
		MOVOU B3, T2
		PCLMULQDQ $0x00, B0, T0
		PCLMULQDQ $0x11, B0, T1
		PCLMULQDQ $0x00, B1, T2

		PXOR T0, T2
		PXOR T1, T2
		MOVOU T2, B4

        buildB.buildFile << """
            dependencies { implementation project(':b1') }
        """

        when:
        execute(buildA, ":dependencies")

        then:
        outputContains("""
runtimeClasspath - Runtime classpath of source set 'main'.
\\--- org.test:${dependencyName}:1.0 -> project :${buildName}
     \\--- project :${buildName}:b1
""")

        where:

        }
        moduleA.dependencies.targetModuleName == ['buildB-b1', 'buildA-buildC', 'buildD-b1']

        originalResult.getIdeaProject('buildB').modules.name == ['buildB', 'buildB-b1', 'b2']
        originalResult.getIdeaProject('buildC').modules.name == ['buildA-buildC']
        originalResult.getIdeaProject('buildD').modules.name == ['buildD', 'buildD-b1', 'buildD-buildC']


        when: "fetching with Isolated Projects"

00000010  31 f3 b1 d8 c7 c9 26 6d  74 0a c0 c0 c0 39 ad b5  |1.....&mt....9..|
00000020  1b b1 dc d3 15 9f a4 96  27 dd 65 85 ad 83 2f 97  |........'.e.../.|
00000030  42 6f 8a 9b 58 fc f8 1b  54 89 cd 9c 11 10 b9 1d  |Bo..X...T.......|
00000040  c3 e1 8e 89 20 a5 2d 0b  31 b5 e0 16 54 ce 93 9b  |.... .-.1...T...|
00000050  de cc b1 af 48 48 33 96  4d a6 00 78 7b 60 3f 7c  |....HH3.M..x{`?||

	c1.SetReadDeadline(time.Now().Add(time.Millisecond))
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()

			b1 := make([]byte, 1024)
			b2 := make([]byte, 1024)
			for j := 0; j < 100; j++ {
				_, err := c1.Read(b1)
				copy(b1, b2) // Mutate b1 to trigger potential race
				if err != nil {
					checkForTimeoutError(t, err)
					c1.SetReadDeadline(time.Now().Add(time.Millisecond))
				}

00000120  51 29 73 c4 ad 34 e5 69  78 18 eb 03 55 c0 c6 0d  |Q)s..4.ix...U...|
00000130  43 d5 4a 5d cb 53 e6 b9  df e8 8b 0e 98 04 89 bb  |C.J].S..........|
00000140  f4 a1 48 01 af d3 42 ef  17 e7 f9 27 b4 b1 63 99  |..H...B....'..c.|
00000150  91 a6 c5 c1 cb 6d 1c 55  b1 69 1c ec b1 b7 c3 cd  |.....m.U.i......|
00000160  7a 93 f2 d8 e4 c4 96 43  0a e1 18 b5 9a 3b 57 83  |z......C.....;W.|
00000170  98 ce 74 f2 4c 65 ad 01  aa 76 b5 b0 7c a0 7d 09  |..t.Le...v..|.}.|