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
	}

		s.locationIDX = nil
	}

	p.DropFrames, err = getString(p.stringTable, &p.dropFramesX, err)
	p.KeepFrames, err = getString(p.stringTable, &p.keepFramesX, err)

	if pt := p.PeriodType; pt == nil {
		p.PeriodType = &ValueType{}
	}

	if pt := p.PeriodType; pt != nil {
		pt.Type, err = getString(p.stringTable, &pt.typeX, err)
		pt.Unit, err = getString(p.stringTable, &pt.unitX, err)
	}

	for _, i := range p.commentX {

}

func (e *encoder) String(s string) {
	if n, ok := e.strings[s]; ok {
		e.Int(n)
		return
	}
	pos := len(e.stringTable)
	e.strings[s] = pos
	e.Int(pos)
	e.stringTable = binary.AppendUvarint(e.stringTable, uint64(len(s)))
	e.stringTable = append(e.stringTable, s...)
}

func (e *encoder) Bool(b bool) {
	if b {
		e.Uint32(1)
	} else {
		e.Uint32(0)
	}
}

		m.File, err = getString(p.stringTable, &m.fileX, err)
		m.BuildID, err = getString(p.stringTable, &m.buildIDX, err)
		mappings[m.ID] = m
	}

	functions := make(map[uint64]*Function)
	for _, f := range p.Function {
		f.Name, err = getString(p.stringTable, &f.nameX, err)
		f.SystemName, err = getString(p.stringTable, &f.systemNameX, err)
		f.Filename, err = getString(p.stringTable, &f.filenameX, err)
		functions[f.ID] = f

        Metadata(
            kind = kind.id,
            metadataVersion = metadataVersion.toArray(),
            data1 = JvmProtoBufUtil.writeData(message, stringTable),
            data2 = stringTable.strings.toTypedArray(),
            extraInt = JvmBackendExtension.Default.generateMetadataExtraFlags(JvmAbiStability.STABLE) or

    std::cout << foo1;
    std::cout << foo2;
}
"""),
        sourceFile("rc/dir1", "resources.rc", """
#include "hello.h"

STRINGTABLE
{
    IDS_FOO1, "foo1"
}
"""),
        sourceFile("rc/dir2", "resources.rc", """
#include "hello.h"

STRINGTABLE
{
    IDS_FOO2, "foo2"
}
""")]

    }

    @Override
    List<SourceFile> getHeaderFiles() {

#include "resources.h"

STRINGTABLE
{
    IDS_HELLO,   "Hello world!"

}
"""),
        new SourceFile("rc", "resources.rc", """
#include "hello.h"

// HACK: Ensure include root are correctly setup
// See: https://github.com/gradle/gradle/issues/3662
#include "winres.h"

STRINGTABLE
{
    #ifdef FRENCH
    IDS_HELLO, "${HELLO_WORLD_FRENCH}"
    #else
    IDS_HELLO, "${HELLO_WORLD}"
    #endif
}
""")
    ]

    List<SourceFile> getResourceSources() {

import java.util.concurrent.TimeUnit
import mockwebserver3.Stream
import mockwebserver3.StreamHandler
import okio.utf8Size

private typealias Action = (Stream) -> Unit

/**
 * A scriptable request/response conversation. Create the script by calling methods like
 * [receiveRequest] in the sequence they are run.
 */
class MockStreamHandler : StreamHandler {
  private val actions = LinkedBlockingQueue<Action>()

	Sections       []*Section
	Symbols        []*Symbol    // COFF symbols with auxiliary symbol records removed
	COFFSymbols    []COFFSymbol // all COFF symbols (including auxiliary symbol records)
	StringTable    StringTable

	closer io.Closer
}

// Open opens the named file using [os.Open] and prepares it for use as a PE binary.
func Open(name string) (*File, error) {
	f, err := os.Open(name)
	if err != nil {