// arm64:-`REV`
	// amd64:-`BSWAPQ`
	binary.BigEndian.PutUint64(b[:], binary.BigEndian.Uint64(x[:]))
}

func store_be32_load(b, x *[8]byte) {
	// arm64:-`REVW`
	// amd64:-`BSWAPL`
	binary.BigEndian.PutUint32(b[:], binary.BigEndian.Uint32(x[:]))
}

func store_be32_idx(b []byte, x uint32, idx int) {
	// amd64/v1,amd64/v2:`BSWAPL`,-`SHR.`
	// amd64/v3:`MOVBEL\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`

                "Method com.example.Task.getSourceCompatibility(): Is not binary compatible." to listOf("Method return type has changed", "Method is now abstract"),
                removed("Method", "Task.setSourceCompatibility(java.lang.String)"),
            )
        }
    }

    @Test
    fun `should automatically accept binary incompatibilities for upgraded properties`() {
        checkBinaryCompatible(
            v1 = {

    private final Map<String, VariantComponent> libsNotMatchingRequirements;
    private final Class<? extends Binary> binaryType;

    private boolean projectNotFound;

    private VariantComponent selectedLibrary;
    private VariantComponent nonMatchingLibrary;

    private LibraryResolutionResult(Class<? extends Binary> binaryType) {
        this.binaryType = binaryType;
        this.libsMatchingRequirements = new HashMap<>();

    public abstract fun getAnalysisSessionByUseSiteKtModule(useSiteKtModule: KtModule): KaSession

    // The `analyse` functions affect binary compatibility as they are inlined with every `analyze` call. To avoid breaking binary
    // compatibility, their implementations should not be changed unless absolutely necessary. It should be possible to put most

# Test to ensure runtime/debug.ReadBuildInfo parses
# the modinfo embedded in a binary by the go tool
# when module is enabled.
env GO111MODULE=on

cd x
go mod edit -require=rsc.io/quote@v1.5.2
go mod edit -replace=rsc.io/quote@v1.5.2=rsc.io/quote@v1.0.0
go mod tidy # populate go.sum

# Build a binary and ensure that it can output its own debug info.
# The debug info should be accessible before main starts (golang.org/issue/29628).
go build

     */
    BinaryNamingScheme withRole(String role, boolean isMain);

    /**
     * Creates a copy of this scheme, replacing the binary type.
     */
    BinaryNamingScheme withBinaryType(String type);

    /**
     * Creates a copy of this scheme, specifying a binary name. This overrides the default binary name that would be generated from the other attributes.

        return verb + StringUtils.capitalize(binary.getProjectScopedName());
    }

    @Override
    public String taskName(String verb, String object) {
        return verb + StringUtils.capitalize(binary.getProjectScopedName()) + StringUtils.capitalize(object);
    }

    @Override
    public Task getBuild() {
        return binary.getBuildTask();
    }

    @Override
    public Task getCheck() {

				t.Log("skipping gold test")
				break
			}
			t.Fatalf("building hello binary: %v", err)
		}
		id, err = buildid.ReadFile(tg.path("hello3.exe"))
		if err != nil {
			t.Fatalf("reading build ID from hello binary (linkmode=external -extldflags=-fuse-ld=gold): %v", err)
		}
		if id != buildID {
			t.Fatalf("buildID in hello binary = %q, want %q (linkmode=external -extldflags=-fuse-ld=gold)", id, buildID)
		}
	}

# The rest have four fields per line: type, format, input, and output.
# The input is given either in decimal or binary scientific notation.
# The output is the string that should be produced by formatting the
# input with the given format.
#
# The formats are as in C's printf, except that %b means print
# binary scientific notation: NpE = N x 2^E.

# TODO:
#	Powers of 10.
#	Powers of 2.
#	%.20g versions.
#	random sources

        }

        @Override
        public boolean applyToBinary(BinarySpec binary) {
            return binary instanceof NativeBinarySpec && shouldProcessResources((NativeBinarySpec) binary);
        }

        private boolean shouldProcessResources(NativeBinarySpec binary) {
            return binary.getTargetPlatform().getOperatingSystem().isWindows();
        }
    }