Name:           "386",
	Family:         I386,
	ByteOrder:      binary.LittleEndian,
	PtrSize:        4,
	RegSize:        4,
	MinLC:          1,
	Alignment:      1,
	CanMergeLoads:  true,
	HasLR:          false,
	FixedFrameSize: 0,
}

var ArchAMD64 = &Arch{
	Name:           "amd64",
	Family:         AMD64,
	ByteOrder:      binary.LittleEndian,
	PtrSize:        8,
	RegSize:        8,
	MinLC:          1,

import org.gradle.model.ModelMap;

/**
 * Represents a binary that is the result of building a component.
 */
@Incubating @HasInternalProtocol
public interface BinarySpec extends BuildableComponentSpec, CheckableComponentSpec, Binary {

    /**
     * Can this binary be built in the current environment?
     */
    boolean isBuildable();

    /**
     * The sources owned by this binary.
     *

	}
	for _, v := range data {
		err := binary.Write(buf, binary.LittleEndian, v)
		if err != nil {
			fmt.Println("binary.Write failed:", err)
		}
	}
	fmt.Printf("%x", buf.Bytes())
	// Output: beefcafe
}

func ExampleRead() {
	var pi float64
	b := []byte{0x18, 0x2d, 0x44, 0x54, 0xfb, 0x21, 0x09, 0x40}
	buf := bytes.NewReader(b)
	err := binary.Read(buf, binary.LittleEndian, &pi)
	if err != nil {

	case "arm":
		binary.LittleEndian.PutUint32(ill[0:4], 0xe3a00000) // MOVW $0, R0
		binary.LittleEndian.PutUint32(ill[4:8], 0xe5800000) // MOVW R0, (R0)
	case "arm64":
		binary.LittleEndian.PutUint32(ill, 0xf90003ff) // MOVD ZR, (ZR)
	case "ppc64":
		binary.BigEndian.PutUint32(ill, 0xf8000000) // MOVD R0, (R0)
	case "ppc64le":
		binary.LittleEndian.PutUint32(ill, 0xf8000000) // MOVD R0, (R0)

                binaries.add(new DefaultCppExecutableModel(binary.getName(), cppBinary.getIdentity().getName(), binary.getBaseName().get(), compilationDetails, linkageDetails));
            } else if (binary instanceof CppSharedLibrary) {
                CppSharedLibrary sharedLibrary = (CppSharedLibrary) binary;
                LinkSharedLibrary linkTask = sharedLibrary.getLinkTask().get();

    }

    def "binary has name and sensible display name"() {
        def binary = create(SampleBinary, MySampleBinary, "sampleBinary")

        expect:
        binary instanceof SampleBinary
        binary.name == "sampleBinary"
        binary.projectScopedName == "sampleBinary"
        binary.displayName == "SampleBinary 'sampleBinary'"
        binary.namingScheme.description == "sample binary 'sampleBinary'"

        binary.targetPlatform == targetPlatform
        binary.toolChain == toolChain
        binary.platformToolProvider == platformToolProvider

        app.binaries.realizeNow()
        app.binaries.get() == [binary] as Set
    }

    def "throws exception when development binary is not available"() {
        given:
        app.binaries.realizeNow()

        when:
        app.developmentBinary.get()

        then:

ISTIO_ENVOY_LINUX_RELEASE_PATH="${ISTIO_ENVOY_LINUX_RELEASE_PATH:-${ISTIO_ENVOY_LINUX_RELEASE_DIR}/${ISTIO_ENVOY_LINUX_RELEASE_NAME}}"

# There is no longer an Istio built Envoy binary available for the Mac. Copy the Linux binary as the Mac binary was
# very old and likely no one was really using it (at least temporarily).

# Download Envoy debug and release binaries for Linux x86_64. They will be included in the

		if cidr.IP.To4() != nil {
			ipInt := binary.BigEndian.Uint32(cidr.IP) | (^binary.BigEndian.Uint32(cidr.Mask))
			binary.BigEndian.PutUint32(ip, ipInt)
		} else {
			// ipIntLeft          |         ipIntRight
			// 2001:0DB8:1234:0000:0000:0000:0000:0000
			ipIntLeft := binary.BigEndian.Uint64(cidr.IP[:net.IPv6len/2]) | (^binary.BigEndian.Uint64(cidr.Mask[:net.IPv6len/2]))

        def binary = new File("any")
        when:
        def metadata = metadataProvider(compiler).getCompilerMetaData([]) { it.executable(binary) }

        then:
        interaction compilerShouldBeExecuted

        when:
        def newMetadata = metadataProvider(compiler).getCompilerMetaData([]) { it.executable(binary) }

        then:
        0 * _