// Copyright 2023 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 chacha8rand

var Block = block
var Block_generic = block_generic

func Seed(s *State) [4]uint64 {
	return s.seed

	}

	Block(&seed, &b1, 4)
	Block_generic(&seed, &b2, 4)
	if !slices.Equal(b1[:], b2[:]) {
		var out bytes.Buffer
		fmt.Fprintf(&out, "%-18s %-18s\n", "block", "block_generic")
		for i := range b1 {
			suffix := ""
			if b1[i] != b2[i] {
				suffix = " mismatch!"
			}
			fmt.Fprintf(&out, "%#016x %#016x%s\n", b1[i], b2[i], suffix)
		}
		t.Errorf("block and block_generic disagree:\n%s", out.String())
	}
}

}

func _() {
	// block and block_generic must have same type
	x := block
	x = block_generic
	_ = x
}

// block_generic is the non-assembly block implementation,
// for use on systems without special assembly.
// Even on such systems, it is quite fast: on GOOS=386,
// ChaCha8 using this code generates random values faster than PCG-DXSM.
func block_generic(seed *[4]uint64, buf *[32]uint64, counter uint32) {

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

//go:build !amd64 && !arm64

#include "textflag.h"

// func block(counter uint64, seed *[8]uint32, blocks *[16][4]uint32)
TEXT ·block(SB), NOSPLIT, $0

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

//go:build purego || (!amd64 && !386 && !ppc64le && !ppc64)

package notsha256

func block(dig *digest, p []byte) {
	blockGeneric(dig, p)

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

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

package md5

const haveAsm = false

func block(dig *digest, p []byte) {
	blockGeneric(dig, p)

	// Note that we currently call block or blockGeneric
	// directly (guarded using haveAsm) because this allows
	// escape analysis to see that p and d don't escape.
	nn = len(p)
	d.len += uint64(nn)
	if d.nx > 0 {
		n := copy(d.x[d.nx:], p)
		d.nx += n
		if d.nx == BlockSize {
			if haveAsm {
				block(d, d.x[:])
			} else {
				blockGeneric(d, d.x[:])
			}
			d.nx = 0
		}
		p = p[n:]

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

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

package sha256

func block(dig *digest, p []byte) {
	blockGeneric(dig, p)

//go:build !purego

package sha512

import "internal/cpu"

func block(dig *digest, p []byte) {
	if cpu.ARM64.HasSHA512 {
		blockAsm(dig, p)
		return
	}
	blockGeneric(dig, p)
}

//go:noescape

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

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

package sha1

func block(dig *digest, p []byte) {
	blockGeneric(dig, p)