telemetry.Inc("go/platform/target/goamd64:" + cfg.GOAMD64)
	case "arm":
		telemetry.Inc("go/platform/target/goarm:" + cfg.GOARM)
	case "arm64":
		telemetry.Inc("go/platform/target/goarm64:" + cfg.GOARM64)
	case "mips":
		telemetry.Inc("go/platform/target/gomips:" + cfg.GOMIPS)
	case "ppc64":
		telemetry.Inc("go/platform/target/goppc64:" + cfg.GOPPC64)
	case "riscv64":
		telemetry.Inc("go/platform/target/goriscv64:" + cfg.GORISCV64)

//
// NOTE fields are exported to be used by TestSiginfoChildLayout.
type SiginfoChild struct {
	Signo       int32
	siErrnoCode                // Two int32 fields, swapped on MIPS.
	_           [is64bit]int32 // Extra padding for 64-bit hosts only.

	// End of common part. Beginning of signal-specific part.

	Pid    int32
	Uid    uint32
	Status int32

	// Pad to 128 bytes.

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

//go:build !purego

// SHA256 block routine. See sha256block.go for Go equivalent.
//
// The algorithm is detailed in FIPS 180-4:
//
//  https://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf
//
// Wt = Mt; for 0 <= t <= 15
// Wt = SIGMA1(Wt-2) + SIGMA0(Wt-15) + Wt-16; for 16 <= t <= 63
//
// a = H0
// b = H1
// c = H2
// d = H3
// e = H4
// f = H5

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
  - 49965
releaseNotes:
- |

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
releaseNotes:
- |

// Copyright 2022 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.

//go:build linux && (mips || mipsle)

#include "textflag.h"

// func Syscall6(num, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, errno uintptr)
//
// The 5th and 6th arg go at sp+16, sp+20.
// Note that frame size of 20 means that 24 bytes gets reserved on stack.
TEXT ·Syscall6(SB),NOSPLIT,$20-40

	}

	priv := new(PrivateKey)
	priv.PublicKey.Curve = c
	priv.D = k
	priv.PublicKey.X, priv.PublicKey.Y = c.ScalarBaseMult(k.Bytes())
	return priv, nil
}

// hashToInt converts a hash value to an integer. Per FIPS 186-4, Section 6.4,
// we use the left-most bits of the hash to match the bit-length of the order of
// the curve. This also performs Step 5 of SEC 1, Version 2.0, Section 4.1.3.

	if err != nil {
		return nil, err
	}
	if _, err := p.ScalarMult(p, local.privateKey); err != nil {
		return nil, err
	}
	return p.BytesX()
}

// P256 returns a [Curve] which implements NIST P-256 (FIPS 186-3, section D.2.3),
// also known as secp256r1 or prime256v1.
//
// Multiple invocations of this function will return the same value, which can
// be used for equality checks and switch statements.

	// a final "1" bit. We merge the first "1" bit from the padding into dsbyte,
	// giving 00000110b (0x06) and 00011111b (0x1f).
	// [1] http://csrc.nist.gov/publications/drafts/fips-202/fips_202_draft.pdf
	//     "Draft FIPS 202: SHA-3 Standard: Permutation-Based Hash and
	//      Extendable-Output Functions (May 2014)"
	dsbyte byte

	i, n    int // storage[i:n] is the buffer, i is only used while squeezing

			for _, cluster := range t.Clusters() {
				if _, ok := gatewayAddresses[cluster.NetworkName()]; ok {
					continue
				}
				ips, ports := i.EastWestGatewayFor(cluster).AddressesForPort(15443)
				if ips != nil {
					gatewayAddresses[cluster.NetworkName()] = gwAddr{ips[0], ports[0]}
				}
			}
			if len(t.Clusters().Networks()) != len(gatewayAddresses) {
				t.Skip("must have an east-west for each network")
			}