func cstring(b []byte) string {
	i := bytes.IndexByte(b, 0)
	if i == -1 {
		i = len(b)
	}
	return string(b[:i])
}

// StringTable is a COFF string table.
type StringTable []byte

func readStringTable(fh *FileHeader, r io.ReadSeeker) (StringTable, error) {
	// COFF string table is located right after COFF symbol table.
	if fh.PointerToSymbolTable <= 0 {
		return nil, nil
	}

    gradleJars: Iterable<File>,
    pluginDependenciesSpecQualifiedName: String,
    pluginDependencySpecQualifiedName: String,
) {
    file.bufferedWriter().use { writer ->
        writer.appendReproducibleNewLine(fileHeader)
        pluginIdExtensionDeclarationsFor(
            gradleJars,
            pluginDependenciesSpecQualifiedName,
            pluginDependencySpecQualifiedName
        ).forEach { extension ->

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package pe

type FileHeader struct {
	Machine              uint16
	NumberOfSections     uint16
	TimeDateStamp        uint32
	PointerToSymbolTable uint32
	NumberOfSymbols      uint32
	SizeOfOptionalHeader uint16
	Characteristics      uint16
}

type DataDirectory struct {

// For cloned PDF see:
// https://github.com/aidansteele/osx-abi-macho-file-format-reference

package macho

import "strconv"

// A FileHeader represents a Mach-O file header.
type FileHeader struct {
	Magic  uint32
	Cpu    Cpu
	SubCpu uint32
	Type   Type
	Ncmd   uint32
	Cmdsz  uint32
	Flags  uint32
}

const (
	fileHeaderSize32 = 7 * 4

		if err != nil {
			log.Fatal(err)
		}
		if strings.HasSuffix(path, ".zip") {
			log.Fatalf("unexpected file during walk: %s", path)
		}
		name := filepath.ToSlash(path)
		w, err := zw.CreateRaw(&zip.FileHeader{
			Name:               name,
			Method:             zip.Store,
			CompressedSize64:   uint64(len(data)),
			UncompressedSize64: uint64(len(data)),
			CRC32:              crc32.ChecksumIEEE(data),
		})

import org.gradle.kotlin.dsl.concurrent.IO
import org.gradle.kotlin.dsl.concurrent.withAsynchronousIO
import org.gradle.kotlin.dsl.concurrent.writeFile
import org.gradle.kotlin.dsl.internal.sharedruntime.codegen.fileHeader
import org.gradle.kotlin.dsl.internal.sharedruntime.codegen.kotlinDslPackagePath
import org.gradle.kotlin.dsl.internal.sharedruntime.support.appendReproducibleNewLine

	}
	defer f.Close()

	wantFileHeader := FileHeader{
		Class:     ELFCLASS32,
		Data:      ELFDATA2LSB,
		Version:   EV_CURRENT,
		OSABI:     ELFOSABI_NONE,
		ByteOrder: binary.LittleEndian,
		Type:      ET_REL,
		Machine:   EM_386,
	}
	if f.FileHeader != wantFileHeader {
		t.Errorf("\nhave %#v\nwant %#v\n", f.FileHeader, wantFileHeader)
	}

	wantSectionNum := 65298

	if textsect == nil {
		return fmt.Errorf("missing __text section")
	}

	cmdOffset := unsafe.Sizeof(exem.FileHeader)
	if is64bit := exem.Magic == macho.Magic64; is64bit {
		// mach_header_64 has one extra uint32.
		cmdOffset += unsafe.Sizeof(exem.Magic)
	}
	dwarfCmdOffset := uint32(cmdOffset) + exem.FileHeader.Cmdsz
	availablePadding := textsect.Offset - dwarfCmdOffset
	if availablePadding < realdwarf.Len {

		{"File", Type, 0},
		{"File.FileHeader", Field, 0},
		{"FileHeader", Type, 0},
		{"FileHeader.CRC32", Field, 0},
		{"FileHeader.Comment", Field, 0},
		{"FileHeader.CompressedSize", Field, 0},
		{"FileHeader.CompressedSize64", Field, 1},
		{"FileHeader.CreatorVersion", Field, 0},
		{"FileHeader.ExternalAttrs", Field, 0},
		{"FileHeader.Extra", Field, 0},
		{"FileHeader.Flags", Field, 0},

import org.gradle.kotlin.dsl.concurrent.withAsynchronousIO
import org.gradle.kotlin.dsl.concurrent.withSynchronousIO
import org.gradle.kotlin.dsl.concurrent.writeFile
import org.gradle.kotlin.dsl.internal.sharedruntime.codegen.fileHeader
import org.gradle.kotlin.dsl.internal.sharedruntime.codegen.fileHeaderFor
import org.gradle.kotlin.dsl.internal.sharedruntime.codegen.kotlinDslPackagePath