def lines = process.inputStream.readLines()
        def archString = lines.last().split()[1]

        switch (archString) {
            case "I386":
                return Architectures.forInput("x86")
            case "X86_64":
                return Architectures.forInput("x86_64")
            default:

// by them is useful for defining GOARCH-specific constants.
//
//go:generate go run gengoarch.go

type ArchFamilyType int

const (
	AMD64 ArchFamilyType = iota
	ARM
	ARM64
	I386
	LOONG64
	MIPS
	MIPS64
	PPC64
	RISCV64
	S390X
	WASM
)

// PtrSize is the size of a pointer in bytes - unsafe.Sizeof(uintptr(0)) but as an ideal constant.

    }

    private static Architecture getArchitecture(SystemInfo systemInfo) {
        SystemInfo.Architecture architecture = systemInfo.getArchitecture();
        switch (architecture) {
            case i386:
                return Architecture.X86;
            case amd64:
                return Architecture.X86_64;
            case aarch64:
                return Architecture.AARCH64;
        }

        return ['c', 'cpp', 'assembler']
    }

    String getExtraConfiguration() {
        return """
            model {
                platforms {
                    x86 {
                        architecture "i386"
                    }
                }
                components {
                    all { it.targetPlatform "x86" }
                }
            }
"""
    }

    SourceFile getMainSource() {

			MTU:  int(nativeEndian.Uint32(m.raw[m.extOff+8 : m.extOff+12])),
		},
	}
}

var compatFreeBSD32 bool // 386 emulation on amd64

func probeRoutingStack() (int, map[int]*wireFormat) {
	var p uintptr
	wordSize := int(unsafe.Sizeof(p))
	align := wordSize
	// In the case of kern.supported_archs="amd64 i386", we need
	// to know the underlying kernel's architecture because the

        this.systemInfo = systemInfo;
    }

    @Override
    public WindowsSdk forPlatform(final NativePlatformInternal platform) {
        String host;
        switch (systemInfo.getArchitecture()) {
            case i386:
                host = "x86";
                break;
            case amd64:
                host = "x64";
                break;
            case aarch64:
                host = "arm64";
                break;

        UnitTestPreconditions.NotWindows
    ])
    def "reassembles binary with target platform change"() {
        when:
        buildFile.text = buildFile.text.replace("i386", "x86-64")

        run "installMainExecutable"

        then:
        executedAndNotSkipped ":assembleHelloSharedLibraryHelloAsm"

		Gentext:          gentext,
		Machoreloc1:      machoreloc1,
		PEreloc1:         pereloc1,

		ELF: ld.ELFArch{
			Linuxdynld:     "/lib/ld-linux.so.2",
			LinuxdynldMusl: "/lib/ld-musl-i386.so.1",
			Freebsddynld:   "/usr/libexec/ld-elf.so.1",
			Openbsddynld:   "/usr/libexec/ld.so",
			Netbsddynld:    "/usr/libexec/ld.elf_so",
			Solarisdynld:   "/lib/ld.so.1",

			Reloc1:    elfreloc1,
			RelocSize: 8,

    def component = BaseComponentFixtures.createNode(NativeLibrarySpec, TestNativeComponentSpec, id)

    def platform1 = Stub(NativePlatform) {
        getArchitecture() >> Architectures.forInput("i386")
    }
    def buildType1 = Stub(BuildType) {
        getName() >> "BuildType1"
    }
    def resolver = Mock(NativeDependencyResolver)

    def "uses resolver to resolve lib to dependency"() {

			return true
		}
		return t.linkShared || (t.HeadType == objabi.Haix && t.LinkMode == LinkExternal)
	}
}

//
// Processor functions
//

func (t *Target) Is386() bool {
	return t.Arch.Family == sys.I386
}

func (t *Target) IsARM() bool {
	return t.Arch.Family == sys.ARM
}

func (t *Target) IsARM64() bool {
	return t.Arch.Family == sys.ARM64
}

func (t *Target) IsAMD64() bool {