private fun FirScope.isScopeForClassCloserThanAnotherScopeForClass(another: FirScope, from: KtClassOrObject): Boolean {
        // Make sure both are scopes for classes
        if (!isScopeForClass() || !another.isScopeForClass()) return false

        if (this == another) return false

        val classId = correspondingClassIdIfExists()
        val classIdOfAnother = another.correspondingClassIdIfExists()

                    val myD = newD("shared")

                    val c1 = c(1)
                    c1.x = c1.f(c1.y)
                    c1.d = myD

                    c(2) {
                        x = f("another test")
                        this.d = myD
                    }
                """.trimIndent()
            )
        )
    }
}


object BuilderFunctionsDemo {
    @JvmStatic

    }

    /**
     * Syncs our internal clock with the system clock and returns the new time.
     * Marks the current time as the last synchronization point, unless another thread already did a synchronization in the meantime.
     */
    private long sync(long syncMillis) {
        long newSyncMillis = advance(timeSource.currentTimeMillis());

        )
    }

    override fun getAllowedContainingFiles(mainFile: KtFile, testServices: TestServices): Set<KtFile> {
        // The reference may be from another file, so we need to allow all main test files
        return testServices.ktTestModuleStructure.allMainKtFiles.toSet()
    }

                    LOGGER.debug("Lock on {} requested by another process - releasing lock.", cacheDisplayName);
                    releaseLockIfHeld();
                    signal.trigger();
                } else {
                    // Lock is in use - mark as contended
                    LOGGER.debug("Lock on {} requested by another process - lock is in use and will be released when operation completed.", cacheDisplayName);

     *
     * #### Examples
     *
     *  - The name of the module is being changed.
     *  - The module's content roots are being changed, such as adding another source folder to a source module.
     *  - If module A depends on module B and module B is being removed, in addition to the removal event for module B, module A also
     *    receives an update event.
     */
    UPDATE,

 */

package org.gradle.internal.serialize.kryo

import spock.lang.Specification

class KryoBackedDecoderTest extends Specification {
    def "can read from stream and then restart to use another stream"() {
        def input1 = encoded("string 1")
        def input2 = encoded("string 2")

        given:
        def decoder = new KryoBackedDecoder(input1)
        decoder.readString()

}

static void bar() {
    go_callback2();
}
*/
import "C"

import (
	"log"
	"os"
	"runtime"
	"runtime/trace"
)

//export go_callback
func go_callback() {
	// Do another call into C, just to test that path too.
	C.bar()
}

//export go_callback2
func go_callback2() {
	runtime.GC()
}

func main() {
	// Start tracing.
	if err := trace.Start(os.Stdout); err != nil {

        return loaded.get();
    }

    @Override
    public void loadLocally(HashCode key, Consumer<? super File> reader) {
        // We need to lock other processes out here because garbage collection can be under way in another process
        persistentCache.withFileLock(() -> {
            // Additional locking necessary because of https://github.com/gradle/gradle/issues/3537
            lock.readLock().lock();
            try {

	err = syscall.GetFileAttributesEx(namep, syscall.GetFileExInfoStandard, (*byte)(unsafe.Pointer(&fa)))
	if err == nil && fa.FileAttributes&syscall.FILE_ATTRIBUTE_REPARSE_POINT == 0 {
		// Not a surrogate for another named entity, because it isn't any kind of reparse point.
		// The information we got from GetFileAttributesEx is good enough for now.
		fs := newFileStatFromWin32FileAttributeData(&fa)