if (repository == publishing.repositories.external)
            return publication == publishing.publications.binary
        if (repository == publishing.repositories.internal)
            return publication == publishing.publications.binaryAndSources
        return false
    }
    onlyIf("publishing binary to the external repository, or binary and sources to the internal one") {
        publishIf.get()
    }
}
// end::task-config[]

// license that can be found in the LICENSE file.

// Issue 44823: miscompilation with store combining.

package main

import "encoding/binary"

//go:noinline
func Id(a [8]byte) (x [8]byte) {
	binary.LittleEndian.PutUint64(x[:], binary.LittleEndian.Uint64(a[:]))
	return
}

var a = [8]byte{1, 2, 3, 4, 5, 6, 7, 8}

func main() {
	x := Id(a)
	if x != a {
		panic("FAIL")
	}

	var ida []ImportDirectory
	for len(d) >= 20 {
		var dt ImportDirectory
		dt.OriginalFirstThunk = binary.LittleEndian.Uint32(d[0:4])
		dt.TimeDateStamp = binary.LittleEndian.Uint32(d[4:8])
		dt.ForwarderChain = binary.LittleEndian.Uint32(d[8:12])
		dt.Name = binary.LittleEndian.Uint32(d[12:16])
		dt.FirstThunk = binary.LittleEndian.Uint32(d[16:20])
		d = d[20:]
		if dt.OriginalFirstThunk == 0 {
			break
		}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"encoding/binary"
)

var (
	ch1 = make(chan int)
	ch2 = make(chan int)

	bin  = []byte("a\000\000\001")
	want = binary.BigEndian.Uint32(bin)

	c consumer = noopConsumer{}
)

type msg struct {
	code uint32
}

type consumer interface {
	consume(msg)
}

                                                                                      NativePlatform platform, BuildType buildType, Flavor flavor) {
        T binary = BaseBinaryFixtures.create(publicType, implType, name, componentNode);
        NativeBinaries.initialize(binary, namingScheme, resolver, TestFiles.fileCollectionFactory(), platform, buildType, flavor);

import org.gradle.api.Action;
import org.gradle.api.provider.Provider;

/**
 * Represents a binary that is created and configured as required.
 *
 * @since 4.5
 * @param <T> The type of binary.
 */
public interface BinaryProvider<T> extends Provider<T> {
    /**
     * Registers an action to execute to configure the binary. The action is executed only when the element is required.
     */

        """
        buildFile << """
            apply plugin: 'cpp-application'

            application {
                binaries.configureEach { binary ->
                    binary.compileTask.get().macros["TEST"] = null
                    binary.compileTask.get().macros["foo"] = "bar"
                }
            }
        """

        and:
        run "visualStudio"

        then:

	}

	ph := new(prog)
	if err := binary.Read(sr, binary.BigEndian, ph); err != nil {
		return nil, err
	}

	f := &File{FileHeader: FileHeader{
		Magic:       ph.Magic,
		Bss:         ph.Bss,
		Entry:       uint64(ph.Entry),
		PtrSize:     4,
		LoadAddress: 0x1000,
		HdrSize:     4 * 8,
	}}

	if ph.Magic&Magic64 != 0 {
		if err := binary.Read(sr, binary.BigEndian, &f.Entry); err != nil {

      "WINDOW_UPDATE", "CONTINUATION",
    )

  /**
   * Lookup table for valid flags for DATA, HEADERS, CONTINUATION. Invalid combinations are
   * represented in binary.
   */
  private val FLAGS = arrayOfNulls<String>(0x40) // Highest bit flag is 0x20.
  private val BINARY =
    Array(256) {
      format("%8s", Integer.toBinaryString(it)).replace(' ', '0')
    }

  init {
    FLAGS[FLAG_NONE] = ""

			// Read the frame data.
			pc, err := binary.ReadUvarint(r)
			if err != nil {
				return fmt.Errorf("reading frame %d's PC for stack %d: %w", i+1, id, err)
			}
			funcID, err := binary.ReadUvarint(r)
			if err != nil {
				return fmt.Errorf("reading frame %d's funcID for stack %d: %w", i+1, id, err)
			}
			fileID, err := binary.ReadUvarint(r)
			if err != nil {