| 64-bit PowerPC LE (ppc64le)    | <https://dl.min.io/server/minio/release/linux-ppc64le/minio> |
| IBM Z-Series (S390X)           | <https://dl.min.io/server/minio/release/linux-s390x/minio>   |

	{
		// Test that a multiply-accumulate operation with intermediate
		// rounding forced by a float32() cast produces the expected
		// result.
		// Test cases generated experimentally on a system (s390x) that
		// supports fused multiply-add instructions.
		var tests = [...]struct{ x, y, z, res float32 }{
			{0.6046603, 0.9405091, 0.6645601, 1.2332485},      // fused multiply-add result: 1.2332486

	} else if x == 385 {
		x += 385
	} else if x == 386 {
		x += 386
	} else if x == 387 {
		x += 387
	} else if x == 388 {
		x += 388
	} else if x == 389 {
		x += 389
	} else if x == 390 {
		x += 390
	} else if x == 391 {
		x += 391
	} else if x == 392 {
		x += 392
	} else if x == 393 {
		x += 393
	} else if x == 394 {
		x += 394
	} else if x == 395 {
		x += 395

                goal += ":" + tok[idx];
            }
        } else if (numTokens == 3) {
            // groupId:artifactId:goal or pluginPrefix:version:goal (since Maven 3.9.0)

            String firstToken = tok[0];
            // groupId or pluginPrefix? heuristics: groupId contains dot (.) but not pluginPrefix
            if (firstToken.contains(".")) {

}

func TestLOONG64OperandParser(t *testing.T) {
	parser := newParser("loong64")
	testOperandParser(t, parser, loong64OperandTests)
}

func TestS390XOperandParser(t *testing.T) {
	parser := newParser("s390x")
	testOperandParser(t, parser, s390xOperandTests)
}

func TestFuncAddress(t *testing.T) {
	type subtest struct {
		arch  string
		tests []operandTest
	}
	for _, sub := range []subtest{

	asmArchRISCV64  = asmArch{name: "riscv64", bigEndian: false, stack: "SP", lr: true, retRegs: []string{"X10", "F10"}}
	asmArchS390X    = asmArch{name: "s390x", bigEndian: true, stack: "R15", lr: true}
	asmArchWasm     = asmArch{name: "wasm", bigEndian: false, stack: "SP", lr: false}
	asmArchLoong64  = asmArch{name: "loong64", bigEndian: false, stack: "R3", lr: true}

	var hk gcmHashKey
	c.Encrypt(hk[:], hk[:])
	g := gcmAsm{
		block:     c,
		hashKey:   hk,
		nonceSize: nonceSize,
		tagSize:   tagSize,
	}
	if cpu.S390X.HasAESGCM {
		g := gcmKMA{g}
		return &g, nil
	}
	return &g, nil
}

func (g *gcmAsm) NonceSize() int {
	return g.nonceSize
}

func (g *gcmAsm) Overhead() int {
	return g.tagSize
}

    - path: cluster/images/etcd/Makefile
      match: BASEIMAGE\?\=registry\.k8s\.io\/build-image\/debian-base-s390x:[a-zA-Z]+\-v((([0-9]+)\.([0-9]+)\.([0-9]+)(?:-([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)
    - path: test/conformance/image/Makefile
      match: BASE_IMAGE_VERSION\?=

//                          256-bit primes"
// https://link.springer.com/article/10.1007%2Fs13389-014-0090-x
// https://eprint.iacr.org/2013/816.pdf

//go:build (amd64 || arm64 || ppc64le || s390x) && !purego

package nistec

import (
	_ "embed"
	"errors"
	"internal/byteorder"
	"math/bits"
	"runtime"
	"unsafe"
)

// p256Element is a P-256 base field element in [0, P-1] in the Montgomery

// Second, it eliminates race-related special cases from cgocall and scheduler.
// Third, in long-term it will allow to remove cyclic runtime/race dependency on cmd/go.

// A brief recap of the s390x C calling convention.
// Arguments are passed in R2...R6, the rest is on stack.
// Callee-saved registers are: R6...R13, R15.
// Temporary registers are: R0...R5, R14.