From 2bd3724e6b0c05cd68fe5524680dabcf36695e22 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Wed, 8 May 2024 11:23:48 +0200 Subject: [PATCH 01/16] add support for avx512 on Sum64 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ``` goos: linux goarch: amd64 pkg: github.com/cespare/xxhash/v2 cpu: AMD Ryzen 9 7950X 16-Core Processor │ /tmp/old.results │ /tmp/new.results │ │ sec/op │ sec/op vs base │ Sum64/4B 2.295n ± 5% 3.018n ± 2% +31.53% (p=0.000 n=10) Sum64/16B 3.103n ± 5% 4.168n ± 3% +34.32% (p=0.000 n=10) Sum64/100B 9.865n ± 4% 8.515n ± 3% -13.68% (p=0.000 n=10) Sum64/4KB 201.4n ± 3% 133.1n ± 3% -33.91% (p=0.000 n=10) Sum64/10MB 489.8µ ± 4% 384.4µ ± 3% -21.52% (p=0.000 n=10) geomean 92.93n 88.67n -4.58% │ /tmp/old.results │ /tmp/new.results │ │ B/s │ B/s vs base │ Sum64/4B 1.623Gi ± 4% 1.234Gi ± 2% -23.96% (p=0.000 n=10) Sum64/16B 4.802Gi ± 5% 3.575Gi ± 3% -25.56% (p=0.000 n=10) Sum64/100B 9.441Gi ± 4% 10.937Gi ± 3% +15.85% (p=0.000 n=10) Sum64/4KB 18.49Gi ± 3% 27.99Gi ± 3% +51.33% (p=0.000 n=10) Sum64/10MB 19.01Gi ± 4% 24.23Gi ± 3% +27.41% (p=0.000 n=10) geomean 7.631Gi 7.998Gi +4.81% ``` I've tried to optimize the small numbers but I don't think I can since a huge part of that slowdown is checking the `useAvx512` global. I think that fine 4ns is still extremely fast for a single hash operation. --- gen/avx512.go | 207 +++++++++++++++++++++++++++ go.mod | 5 + go.sum | 60 ++++++++ xxhash_amd64.s | 4 +- xxhash_asm_amd64.go | 27 ++++ xxhash_asm.go => xxhash_asm_arm64.go | 9 +- xxhash_avx512_amd64.s | 152 ++++++++++++++++++++ xxhash_other.go | 2 + xxhash_test.go | 35 ++++- xxhash_unsafe_test.go | 4 +- 10 files changed, 489 insertions(+), 16 deletions(-) create mode 100644 gen/avx512.go create mode 100644 xxhash_asm_amd64.go rename xxhash_asm.go => xxhash_asm_arm64.go (58%) create mode 100644 xxhash_avx512_amd64.s diff --git a/gen/avx512.go b/gen/avx512.go new file mode 100644 index 0000000..0b0310f --- /dev/null +++ b/gen/avx512.go @@ -0,0 +1,207 @@ +package main + +import ( + "github.com/cespare/xxhash/v2" + . "github.com/mmcloughlin/avo/build" + . "github.com/mmcloughlin/avo/operand" + "github.com/mmcloughlin/avo/reg" +) + +const ( + prime1 uint64 = 11400714785074694791 + prime2 uint64 = 14029467366897019727 + prime3 uint64 = 1609587929392839161 + prime4 uint64 = 9650029242287828579 + prime5 uint64 = 2870177450012600261 +) + +func round0(v /*inout*/, p1, p2 reg.GPVirtual) { + IMULQ(p2, v) + ROLQ(Imm(31), v) + IMULQ(p1, v) +} + +func mergeRound(h /*inout*/, v /*in-destroy*/, p1, p2, p4 reg.GPVirtual) { + round0(v, p1, p2) + XORQ(v, h) + IMULQ(p1, h) + ADDQ(p4, h) +} + +func main() { + initStateAvx512 := GLOBL("·initWideAvx512", NOSPLIT|NOPTR) + prime1 := prime1 + DATA(0, U64(prime1+prime2)) + DATA(8, U64(prime2)) + DATA(16, U64(0)) + DATA(24, U64(-prime1)) + + TEXT("sum64avx512", NOSPLIT|NOFRAME, "func(b []byte) uint64") + p := Load(Param("b").Base(), GP64()) + n := Load(Param("b").Len(), GP64()) + + p1, p2, p3, p4, p5 := GP64(), GP64(), GP64(), GP64(), GP64() + MOVQ(Imm(prime1), p1) + MOVQ(Imm(prime2), p2) + MOVQ(Imm(prime3), p3) + MOVQ(Imm(prime4), p4) + MOVQ(Imm(prime5), p5) + + h := GP64() + LEAQ(Mem{Base: p5, Index: n, Scale: 1}, h) + + TESTQ(n, n) + JZ(LabelRef("zero")) + CMPQ(n, Imm(3)) + JBE(LabelRef("loop_1")) + CMPQ(n, Imm(7)) + JBE(LabelRef("do_4")) + CMPQ(n, Imm(31)) + JBE(LabelRef("loop_8")) + + { + // This loop handles 32 bytes at a time in one YMM register. + // state represent v1, v2, v3, v4 as 4 × uint64. + state := YMM() + VMOVDQU(initStateAvx512, state) + + endp := GP64() + MOVL(U32(31), endp.As32()) + ANDNQ(n, endp, endp) + ADDQ(p, endp) + + yprime1 := YMM() + VPBROADCASTQ(p1, yprime1) + yprime2 := YMM() + VPBROADCASTQ(p2, yprime2) + + Label("loop_32") + { + // main block loop + temp := YMM() + VMOVDQU(Mem{Base: p}, temp) + ADDQ(Imm(32), p) + VPMULLQ(temp, yprime2, temp) + VPADDQ(temp, state, state) + VPROLQ(Imm(31), state, state) + VPMULLQ(state, yprime1, state) + + CMPQ(p, endp) + JNE(LabelRef("loop_32")) + } + + // This interleave two things: extracting v1,2,3,4 from state and computing h. + v1, v2, v3, v4, temp := GP64(), GP64(), GP64(), GP64(), GP64() + VMOVQ(state.AsX(), v1) + MOVQ(v1, h) + ROLQ(Imm(1), h) + + VPEXTRQ(Imm(1), state.AsX(), v2) + MOVQ(v2, temp) + ROLQ(Imm(7), temp) + ADDQ(temp, h) + + VEXTRACTI128(Imm(1), state, state.AsX()) + VMOVQ(state.AsX(), v3) + MOVQ(v3, temp) + ROLQ(Imm(12), temp) + ADDQ(temp, h) + + VPEXTRQ(Imm(1), state.AsX(), v4) + VZEROUPPER() + MOVQ(v4, temp) + ROLQ(Imm(18), temp) + ADDQ(temp, h) + + // We could do round0 in SIMD if it's worth doing the two decompositions. + + mergeRound(h, v1, p1, p2, p4) + mergeRound(h, v2, p1, p2, p4) + mergeRound(h, v3, p1, p2, p4) + mergeRound(h, v4, p1, p2, p4) + + ADDQ(n, h) + ANDQ(Imm(31), n) + } + + // From this point on I didn't bothered writing SIMD code since this will handle at most 31 bytes. + + CMPQ(n, Imm(8)) + JB(LabelRef("skip_8")) + Label("loop_8") + { + temp := GP64() + MOVQ(Mem{Base: p}, temp) + ADDQ(Imm(8), p) + SUBQ(Imm(8), n) + round0(temp, p1, p2) + XORQ(temp, h) + ROLQ(Imm(27), h) + IMULQ(p1, h) + ADDQ(p4, h) + + CMPQ(n, Imm(8)) + JAE(LabelRef("loop_8")) + } + Label("skip_8") + + CMPQ(n, Imm(4)) + JB(LabelRef("skip_4")) + Label("do_4") + { + temp := GP64() + MOVL(Mem{Base: p}, temp.As32()) + ADDQ(Imm(4), p) + SUBQ(Imm(4), n) + IMULQ(p1, temp) + XORQ(temp, h) + ROLQ(Imm(23), h) + IMULQ(p2, h) + ADDQ(p3, h) + } + Label("skip_4") + + TESTQ(n, n) + JZ(LabelRef("skip_1")) + Label("loop_1") + { + temp := GP64() + MOVBLZX(Mem{Base: p}, temp.As32()) + INCQ(p) + IMULQ(p5, temp) + XORQ(temp, h) + ROLQ(Imm(11), h) + IMULQ(p1, h) + + DECQ(n) + JNZ(LabelRef("loop_1")) + } + Label("skip_1") + + temp := GP64() + MOVQ(h, temp) + SHRQ(Imm(33), temp) + XORQ(temp, h) + + IMULQ(p2, h) + + MOVQ(h, temp) + SHRQ(Imm(29), temp) + XORQ(temp, h) + + IMULQ(p3, h) + + MOVQ(h, temp) + SHRQ(Imm(32), temp) + XORQ(temp, h) + + Store(h, ReturnIndex(0)) + RET() + + Label("zero") + MOVQ(U64(xxhash.Sum64([]byte{})), h) + Store(h, ReturnIndex(0)) + RET() + + Generate() +} diff --git a/go.mod b/go.mod index 49f6760..e3385f4 100644 --- a/go.mod +++ b/go.mod @@ -1,3 +1,8 @@ module github.com/cespare/xxhash/v2 go 1.11 + +require ( + github.com/klauspost/cpuid/v2 v2.2.7 + github.com/mmcloughlin/avo v0.6.0 +) diff --git a/go.sum b/go.sum index e69de29..1168a1b 100644 --- a/go.sum +++ b/go.sum @@ -0,0 +1,60 @@ +github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM= +github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= +github.com/mmcloughlin/avo v0.6.0 h1:QH6FU8SKoTLaVs80GA8TJuLNkUYl4VokHKlPhVDg4YY= +github.com/mmcloughlin/avo v0.6.0/go.mod h1:8CoAGaCSYXtCPR+8y18Y9aB/kxb8JSS6FRI7mSkvD+8= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +golang.org/x/arch v0.6.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc= +golang.org/x/crypto v0.16.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= +golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= +golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk= +golang.org/x/net v0.19.0/go.mod h1:CfAk/cbD4CthTvqiEl8NpboMuiuOYsAr/7NOjZJtv1U= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= +golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE= +golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc= +golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo= +golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU= +golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58= +golang.org/x/tools v0.16.1 h1:TLyB3WofjdOEepBHAU20JdNC1Zbg87elYofWYAY5oZA= +golang.org/x/tools v0.16.1/go.mod h1:kYVVN6I1mBNoB1OX+noeBjbRk4IUEPa7JJ+TJMEooJ0= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= diff --git a/xxhash_amd64.s b/xxhash_amd64.s index 3e8b132..76b4543 100644 --- a/xxhash_amd64.s +++ b/xxhash_amd64.s @@ -57,8 +57,8 @@ loop: \ CMPQ p, end \ JLE loop -// func Sum64(b []byte) uint64 -TEXT ·Sum64(SB), NOSPLIT|NOFRAME, $0-32 +// func sum64(b []byte) uint64 +TEXT ·sum64(SB), NOSPLIT|NOFRAME, $0-32 // Load fixed primes. MOVQ ·primes+0(SB), prime1 MOVQ ·primes+8(SB), prime2 diff --git a/xxhash_asm_amd64.go b/xxhash_asm_amd64.go new file mode 100644 index 0000000..3bb3f42 --- /dev/null +++ b/xxhash_asm_amd64.go @@ -0,0 +1,27 @@ +//go:build amd64 && !appengine && gc && !purego +// +build amd64,!appengine,gc,!purego + +//go:generate go run ./gen -out xxhash_avx512_amd64.s + +package xxhash + +import "github.com/klauspost/cpuid/v2" + +var useAvx512 = cpuid.CPU.Supports(cpuid.AVX, cpuid.AVX2, cpuid.AVX512DQ, cpuid.AVX512F, cpuid.AVX512VL, cpuid.BMI1) + +// Sum64 computes the 64-bit xxHash digest of b with a zero seed. +func Sum64(b []byte) uint64 { + if useAvx512 { + return sum64avx512(b) + } + return sum64(b) +} + +//go:noescape +func sum64(b []byte) uint64 + +//go:noescape +func sum64avx512(b []byte) uint64 + +//go:noescape +func writeBlocks(d *Digest, b []byte) int diff --git a/xxhash_asm.go b/xxhash_asm_arm64.go similarity index 58% rename from xxhash_asm.go rename to xxhash_asm_arm64.go index 78f95f2..ede1693 100644 --- a/xxhash_asm.go +++ b/xxhash_asm_arm64.go @@ -1,11 +1,10 @@ -//go:build (amd64 || arm64) && !appengine && gc && !purego -// +build amd64 arm64 -// +build !appengine -// +build gc -// +build !purego +//go:build arm64 && !appengine && gc && !purego +// +build arm64,!appengine,gc,!purego package xxhash +var useAvx512 = false + // Sum64 computes the 64-bit xxHash digest of b with a zero seed. // //go:noescape diff --git a/xxhash_avx512_amd64.s b/xxhash_avx512_amd64.s new file mode 100644 index 0000000..bb24a54 --- /dev/null +++ b/xxhash_avx512_amd64.s @@ -0,0 +1,152 @@ +// Code generated by command: go run avx512.go -out xxhash_avx512_amd64.s. DO NOT EDIT. + +#include "textflag.h" + +DATA ·initWideAvx512<>+0(SB)/8, $0x60ea27eeadc0b5d6 +DATA ·initWideAvx512<>+8(SB)/8, $0xc2b2ae3d27d4eb4f +DATA ·initWideAvx512<>+16(SB)/8, $0x0000000000000000 +DATA ·initWideAvx512<>+24(SB)/8, $0x61c8864e7a143579 +GLOBL ·initWideAvx512<>(SB), NOSPLIT|NOPTR, $32 + +// func sum64avx512(b []byte) uint64 +// Requires: AVX, AVX2, AVX512DQ, AVX512F, AVX512VL, BMI +TEXT ·sum64avx512(SB), NOSPLIT|NOFRAME, $0-32 + MOVQ b_base+0(FP), AX + MOVQ b_len+8(FP), CX + MOVQ $0x9e3779b185ebca87, DX + MOVQ $0xc2b2ae3d27d4eb4f, BX + MOVQ $0x165667b19e3779f9, SI + MOVQ $0x85ebca77c2b2ae63, DI + MOVQ $0x27d4eb2f165667c5, R8 + LEAQ (R8)(CX*1), R9 + TESTQ CX, CX + JZ zero + CMPQ CX, $0x03 + JBE loop_1 + CMPQ CX, $0x07 + JBE do_4 + CMPQ CX, $0x1f + JBE loop_8 + VMOVDQU ·initWideAvx512<>+0(SB), Y0 + MOVL $0x0000001f, R9 + ANDNQ CX, R9, R9 + ADDQ AX, R9 + VPBROADCASTQ DX, Y1 + VPBROADCASTQ BX, Y2 + +loop_32: + VMOVDQU (AX), Y3 + ADDQ $0x20, AX + VPMULLQ Y3, Y2, Y3 + VPADDQ Y3, Y0, Y0 + VPROLQ $0x1f, Y0, Y0 + VPMULLQ Y0, Y1, Y0 + CMPQ AX, R9 + JNE loop_32 + VMOVQ X0, R10 + MOVQ R10, R9 + ROLQ $0x01, R9 + VPEXTRQ $0x01, X0, R11 + MOVQ R11, R14 + ROLQ $0x07, R14 + ADDQ R14, R9 + VEXTRACTI128 $0x01, Y0, X0 + VMOVQ X0, R12 + MOVQ R12, R14 + ROLQ $0x0c, R14 + ADDQ R14, R9 + VPEXTRQ $0x01, X0, R13 + VZEROUPPER + MOVQ R13, R14 + ROLQ $0x12, R14 + ADDQ R14, R9 + IMULQ BX, R10 + ROLQ $0x1f, R10 + IMULQ DX, R10 + XORQ R10, R9 + IMULQ DX, R9 + ADDQ DI, R9 + IMULQ BX, R11 + ROLQ $0x1f, R11 + IMULQ DX, R11 + XORQ R11, R9 + IMULQ DX, R9 + ADDQ DI, R9 + IMULQ BX, R12 + ROLQ $0x1f, R12 + IMULQ DX, R12 + XORQ R12, R9 + IMULQ DX, R9 + ADDQ DI, R9 + IMULQ BX, R13 + ROLQ $0x1f, R13 + IMULQ DX, R13 + XORQ R13, R9 + IMULQ DX, R9 + ADDQ DI, R9 + ADDQ CX, R9 + ANDQ $0x1f, CX + CMPQ CX, $0x08 + JB skip_8 + +loop_8: + MOVQ (AX), R10 + ADDQ $0x08, AX + SUBQ $0x08, CX + IMULQ BX, R10 + ROLQ $0x1f, R10 + IMULQ DX, R10 + XORQ R10, R9 + ROLQ $0x1b, R9 + IMULQ DX, R9 + ADDQ DI, R9 + CMPQ CX, $0x08 + JAE loop_8 + +skip_8: + CMPQ CX, $0x04 + JB skip_4 + +do_4: + MOVL (AX), DI + ADDQ $0x04, AX + SUBQ $0x04, CX + IMULQ DX, DI + XORQ DI, R9 + ROLQ $0x17, R9 + IMULQ BX, R9 + ADDQ SI, R9 + +skip_4: + TESTQ CX, CX + JZ skip_1 + +loop_1: + MOVBLZX (AX), DI + INCQ AX + IMULQ R8, DI + XORQ DI, R9 + ROLQ $0x0b, R9 + IMULQ DX, R9 + DECQ CX + JNZ loop_1 + +skip_1: + MOVQ R9, AX + SHRQ $0x21, AX + XORQ AX, R9 + IMULQ BX, R9 + MOVQ R9, AX + SHRQ $0x1d, AX + XORQ AX, R9 + IMULQ SI, R9 + MOVQ R9, AX + SHRQ $0x20, AX + XORQ AX, R9 + MOVQ R9, ret+24(FP) + RET + +zero: + MOVQ $0xef46db3751d8e999, R9 + MOVQ R9, ret+24(FP) + RET diff --git a/xxhash_other.go b/xxhash_other.go index 118e49e..073ae02 100644 --- a/xxhash_other.go +++ b/xxhash_other.go @@ -3,6 +3,8 @@ package xxhash +var useAvx512 = false + // Sum64 computes the 64-bit xxHash digest of b with a zero seed. func Sum64(b []byte) uint64 { // A simpler version would be diff --git a/xxhash_test.go b/xxhash_test.go index 8e2f456..5ecae8f 100644 --- a/xxhash_test.go +++ b/xxhash_test.go @@ -9,7 +9,28 @@ import ( "testing" ) -func TestAll(t *testing.T) { +func Test(t *testing.T) { + for { + var suffix string + if useAvx512 { + suffix = "-avx512" + } + + t.Run("All"+suffix, testAll) + t.Run("Reset"+suffix, testReset) + t.Run("ResetWithSeed"+suffix, testResetWithSeed) + t.Run("BinaryMarshaling"+suffix, testBinaryMarshaling) + + if useAvx512 { + useAvx512 = false + defer func() { useAvx512 = true }() + continue + } + return + } +} + +func testAll(t *testing.T) { // Exactly 63 characters, which exercises all code paths. const s63 = "Call me Ishmael. Some years ago--never mind how long precisely-" for _, tt := range []struct { @@ -94,7 +115,7 @@ func testSum(t *testing.T, input string, want uint64) { } } -func TestReset(t *testing.T) { +func testReset(t *testing.T) { parts := []string{"The quic", "k br", "o", "wn fox jumps", " ov", "er the lazy ", "dog."} d := New() for _, part := range parts { @@ -111,7 +132,7 @@ func TestReset(t *testing.T) { } } -func TestResetWithSeed(t *testing.T) { +func testResetWithSeed(t *testing.T) { parts := []string{"The quic", "k br", "o", "wn fox jumps", " ov", "er the lazy ", "dog."} d := NewWithSeed(123) for _, part := range parts { @@ -128,7 +149,7 @@ func TestResetWithSeed(t *testing.T) { } } -func TestBinaryMarshaling(t *testing.T) { +func testBinaryMarshaling(t *testing.T) { d := New() d.WriteString("abc") b, err := d.MarshalBinary() @@ -173,7 +194,7 @@ func TestAllocs(t *testing.T) { // intermediate []byte ought not to escape. // (See https://github.com/cespare/xxhash/pull/2.) t.Run("Sum64", func(t *testing.T) { - testAllocs(t, func() { + runAllocs(t, func() { sink = Sum64([]byte(shortStr)) }) }) @@ -182,7 +203,7 @@ func TestAllocs(t *testing.T) { // hash.Hash64 which forces an allocation.) t.Run("Digest", func(t *testing.T) { b := []byte("asdf") - testAllocs(t, func() { + runAllocs(t, func() { d := New() d.Write(b) sink = d.Sum64() @@ -190,7 +211,7 @@ func TestAllocs(t *testing.T) { }) } -func testAllocs(t *testing.T, fn func()) { +func runAllocs(t *testing.T, fn func()) { t.Helper() if allocs := int(testing.AllocsPerRun(10, fn)); allocs > 0 { t.Fatalf("got %d allocation(s) (want zero)", allocs) diff --git a/xxhash_unsafe_test.go b/xxhash_unsafe_test.go index 6d6f93c..9f5f76c 100644 --- a/xxhash_unsafe_test.go +++ b/xxhash_unsafe_test.go @@ -13,12 +13,12 @@ import ( func TestStringAllocs(t *testing.T) { longStr := strings.Repeat("a", 1000) t.Run("Sum64String", func(t *testing.T) { - testAllocs(t, func() { + runAllocs(t, func() { sink = Sum64String(longStr) }) }) t.Run("Digest.WriteString", func(t *testing.T) { - testAllocs(t, func() { + runAllocs(t, func() { d := New() d.WriteString(longStr) sink = d.Sum64() From 27324bc3913c8cdfcc5e6f7a66861971c0862265 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Wed, 8 May 2024 14:31:48 +0200 Subject: [PATCH 02/16] add avx512 routines for writeBlocks (thus Digest) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ``` goos: linux goarch: amd64 pkg: github.com/cespare/xxhash/v2 cpu: AMD Ryzen 9 7950X 16-Core Processor │ /tmp/old.results │ /tmp/new.results │ │ sec/op │ sec/op vs base │ DigestBytes/4B 9.358n ± 2% 9.377n ± 2% ~ (p=0.481 n=10) DigestBytes/16B 11.48n ± 3% 11.48n ± 1% ~ (p=0.469 n=10) DigestBytes/100B 15.97n ± 2% 20.41n ± 3% +27.80% (p=0.000 n=10) DigestBytes/4KB 212.4n ± 2% 167.7n ± 3% -21.09% (p=0.000 n=10) DigestBytes/10MB 493.2µ ± 3% 380.3µ ± 2% -22.90% (p=0.000 n=10) geomean 178.2n 169.6n -4.87% │ /tmp/old.results │ /tmp/new.results │ │ B/s │ B/s vs base │ DigestBytes/4B 407.6Mi ± 2% 406.8Mi ± 2% ~ (p=0.481 n=10) DigestBytes/16B 1.298Gi ± 3% 1.298Gi ± 1% ~ (p=0.529 n=10) DigestBytes/100B 5.831Gi ± 2% 4.563Gi ± 3% -21.75% (p=0.000 n=10) DigestBytes/4KB 17.54Gi ± 2% 22.22Gi ± 3% +26.72% (p=0.000 n=10) DigestBytes/10MB 18.88Gi ± 2% 24.49Gi ± 2% +29.69% (p=0.000 n=10) geomean 3.979Gi 4.183Gi +5.12% ``` --- gen/avx512.go | 87 +++++++++++++++++++++++++++++-------------- xxhash.go | 41 ++++++++++---------- xxhash_amd64.s | 6 +-- xxhash_asm_amd64.go | 18 +++++++-- xxhash_avx512_amd64.s | 30 +++++++++++++++ xxhash_other.go | 4 +- 6 files changed, 128 insertions(+), 58 deletions(-) diff --git a/gen/avx512.go b/gen/avx512.go index 0b0310f..3689c33 100644 --- a/gen/avx512.go +++ b/gen/avx512.go @@ -28,7 +28,39 @@ func mergeRound(h /*inout*/, v /*in-destroy*/, p1, p2, p4 reg.GPVirtual) { ADDQ(p4, h) } -func main() { +// blockLoop handles 32 bytes at a time in one YMM register. +// state represent v1, v2, v3, v4 as 4 × uint64. +func blockLoop(state /*inout*/, p /*inout*/, n, p1, p2, processed /*out-optional*/ reg.Register) { + endp := GP64() + MOVL(U32(31), endp.As32()) + ANDNQ(n, endp, endp) + if processed != nil { + MOVQ(endp, processed) + } + ADDQ(p, endp) + + yprime1 := YMM() + VPBROADCASTQ(p1, yprime1) + yprime2 := YMM() + VPBROADCASTQ(p2, yprime2) + + Label("loop_32") + { + // main block loop + temp := YMM() + VMOVDQU(Mem{Base: p}, temp) + ADDQ(Imm(32), p) + VPMULLQ(temp, yprime2, temp) + VPADDQ(temp, state, state) + VPROLQ(Imm(31), state, state) + VPMULLQ(state, yprime1, state) + + CMPQ(p, endp) + JNE(LabelRef("loop_32")) + } +} + +func sum64() { initStateAvx512 := GLOBL("·initWideAvx512", NOSPLIT|NOPTR) prime1 := prime1 DATA(0, U64(prime1+prime2)) @@ -60,35 +92,10 @@ func main() { JBE(LabelRef("loop_8")) { - // This loop handles 32 bytes at a time in one YMM register. - // state represent v1, v2, v3, v4 as 4 × uint64. state := YMM() VMOVDQU(initStateAvx512, state) - endp := GP64() - MOVL(U32(31), endp.As32()) - ANDNQ(n, endp, endp) - ADDQ(p, endp) - - yprime1 := YMM() - VPBROADCASTQ(p1, yprime1) - yprime2 := YMM() - VPBROADCASTQ(p2, yprime2) - - Label("loop_32") - { - // main block loop - temp := YMM() - VMOVDQU(Mem{Base: p}, temp) - ADDQ(Imm(32), p) - VPMULLQ(temp, yprime2, temp) - VPADDQ(temp, state, state) - VPROLQ(Imm(31), state, state) - VPMULLQ(state, yprime1, state) - - CMPQ(p, endp) - JNE(LabelRef("loop_32")) - } + blockLoop(state, p, n, p1, p2, nil) // This interleave two things: extracting v1,2,3,4 from state and computing h. v1, v2, v3, v4, temp := GP64(), GP64(), GP64(), GP64(), GP64() @@ -202,6 +209,32 @@ func main() { MOVQ(U64(xxhash.Sum64([]byte{})), h) Store(h, ReturnIndex(0)) RET() +} +func writeBlocks() { + TEXT("writeBlocksAvx512", NOSPLIT|NOFRAME, "func(d *[4]uint64, b []byte) int") + d := Load(Param("d"), GP64()) + p := Load(Param("b").Base(), GP64()) + n := Load(Param("b").Len(), GP64()) + + state := YMM() + VMOVDQU(Mem{Base: d, Disp: 0}, state) + + p1, p2 := GP64(), GP64() + MOVQ(Imm(prime1), p1) + MOVQ(Imm(prime2), p2) + + processed := GP64() + blockLoop(state, p, n, p1, p2, processed) + VMOVDQU(state, Mem{Base: d, Disp: 0}) + VZEROUPPER() + + Store(processed, ReturnIndex(0)) + RET() +} + +func main() { + sum64() + writeBlocks() Generate() } diff --git a/xxhash.go b/xxhash.go index 78bddf1..e3ed38f 100644 --- a/xxhash.go +++ b/xxhash.go @@ -27,10 +27,7 @@ var primes = [...]uint64{prime1, prime2, prime3, prime4, prime5} // Note that a zero-valued Digest is not ready to receive writes. // Call Reset or create a Digest using New before calling other methods. type Digest struct { - v1 uint64 - v2 uint64 - v3 uint64 - v4 uint64 + s [4]uint64 total uint64 mem [32]byte n int // how much of mem is used @@ -57,10 +54,10 @@ func (d *Digest) Reset() { // ResetWithSeed clears the Digest's state so that it can be reused. // It uses the given seed to initialize the state. func (d *Digest) ResetWithSeed(seed uint64) { - d.v1 = seed + prime1 + prime2 - d.v2 = seed + prime2 - d.v3 = seed - d.v4 = seed - prime1 + d.s[0] = seed + prime1 + prime2 + d.s[1] = seed + prime2 + d.s[2] = seed + d.s[3] = seed - prime1 d.total = 0 d.n = 0 } @@ -88,10 +85,10 @@ func (d *Digest) Write(b []byte) (n int, err error) { if d.n > 0 { // Finish off the partial block. c := copy(memleft, b) - d.v1 = round(d.v1, u64(d.mem[0:8])) - d.v2 = round(d.v2, u64(d.mem[8:16])) - d.v3 = round(d.v3, u64(d.mem[16:24])) - d.v4 = round(d.v4, u64(d.mem[24:32])) + d.s[0] = round(d.s[0], u64(d.mem[0:8])) + d.s[1] = round(d.s[1], u64(d.mem[8:16])) + d.s[2] = round(d.s[2], u64(d.mem[16:24])) + d.s[3] = round(d.s[3], u64(d.mem[24:32])) b = b[c:] d.n = 0 } @@ -130,14 +127,14 @@ func (d *Digest) Sum64() uint64 { var h uint64 if d.total >= 32 { - v1, v2, v3, v4 := d.v1, d.v2, d.v3, d.v4 + v1, v2, v3, v4 := d.s[0], d.s[1], d.s[2], d.s[3] h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) h = mergeRound(h, v2) h = mergeRound(h, v3) h = mergeRound(h, v4) } else { - h = d.v3 + prime5 + h = d.s[2] + prime5 } h += d.total @@ -176,10 +173,10 @@ const ( func (d *Digest) MarshalBinary() ([]byte, error) { b := make([]byte, 0, marshaledSize) b = append(b, magic...) - b = appendUint64(b, d.v1) - b = appendUint64(b, d.v2) - b = appendUint64(b, d.v3) - b = appendUint64(b, d.v4) + b = appendUint64(b, d.s[0]) + b = appendUint64(b, d.s[1]) + b = appendUint64(b, d.s[2]) + b = appendUint64(b, d.s[3]) b = appendUint64(b, d.total) b = append(b, d.mem[:d.n]...) b = b[:len(b)+len(d.mem)-d.n] @@ -195,10 +192,10 @@ func (d *Digest) UnmarshalBinary(b []byte) error { return errors.New("xxhash: invalid hash state size") } b = b[len(magic):] - b, d.v1 = consumeUint64(b) - b, d.v2 = consumeUint64(b) - b, d.v3 = consumeUint64(b) - b, d.v4 = consumeUint64(b) + b, d.s[0] = consumeUint64(b) + b, d.s[1] = consumeUint64(b) + b, d.s[2] = consumeUint64(b) + b, d.s[3] = consumeUint64(b) b, d.total = consumeUint64(b) copy(d.mem[:], b) d.n = int(d.total % uint64(len(d.mem))) diff --git a/xxhash_amd64.s b/xxhash_amd64.s index 76b4543..7a60a92 100644 --- a/xxhash_amd64.s +++ b/xxhash_amd64.s @@ -58,7 +58,7 @@ loop: \ JLE loop // func sum64(b []byte) uint64 -TEXT ·sum64(SB), NOSPLIT|NOFRAME, $0-32 +TEXT ·sum64scallar(SB), NOSPLIT|NOFRAME, $0-32 // Load fixed primes. MOVQ ·primes+0(SB), prime1 MOVQ ·primes+8(SB), prime2 @@ -173,8 +173,8 @@ finalize: MOVQ h, ret+24(FP) RET -// func writeBlocks(d *Digest, b []byte) int -TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40 +// func writeBlocksScallar(d *Digest, b []byte) int +TEXT ·writeBlocksScallar(SB), NOSPLIT|NOFRAME, $0-40 // Load fixed primes needed for round. MOVQ ·primes+0(SB), prime1 MOVQ ·primes+8(SB), prime2 diff --git a/xxhash_asm_amd64.go b/xxhash_asm_amd64.go index 3bb3f42..898b9b3 100644 --- a/xxhash_asm_amd64.go +++ b/xxhash_asm_amd64.go @@ -1,7 +1,7 @@ //go:build amd64 && !appengine && gc && !purego // +build amd64,!appengine,gc,!purego -//go:generate go run ./gen -out xxhash_avx512_amd64.s +//go:generate go run -tags purego ./gen -out xxhash_avx512_amd64.s package xxhash @@ -14,14 +14,24 @@ func Sum64(b []byte) uint64 { if useAvx512 { return sum64avx512(b) } - return sum64(b) + return sum64scallar(b) } //go:noescape -func sum64(b []byte) uint64 +func sum64scallar(b []byte) uint64 //go:noescape func sum64avx512(b []byte) uint64 +func writeBlocks(d *Digest, b []byte) int { + if useAvx512 { + return writeBlocksAvx512(&d.s, b) + } + return writeBlocksScallar(d, b) +} + +//go:noescape +func writeBlocksAvx512(d *[4]uint64, b []byte) int + //go:noescape -func writeBlocks(d *Digest, b []byte) int +func writeBlocksScallar(d *Digest, b []byte) int diff --git a/xxhash_avx512_amd64.s b/xxhash_avx512_amd64.s index bb24a54..7e0665a 100644 --- a/xxhash_avx512_amd64.s +++ b/xxhash_avx512_amd64.s @@ -150,3 +150,33 @@ zero: MOVQ $0xef46db3751d8e999, R9 MOVQ R9, ret+24(FP) RET + +// func writeBlocksAvx512(d *[4]uint64, b []byte) int +// Requires: AVX, AVX2, AVX512DQ, AVX512F, AVX512VL, BMI +TEXT ·writeBlocksAvx512(SB), NOSPLIT|NOFRAME, $0-40 + MOVQ d+0(FP), AX + MOVQ b_base+8(FP), CX + MOVQ b_len+16(FP), DX + VMOVDQU (AX), Y0 + MOVQ $0x9e3779b185ebca87, BX + MOVQ $0xc2b2ae3d27d4eb4f, SI + MOVL $0x0000001f, DI + ANDNQ DX, DI, DI + MOVQ DI, DX + ADDQ CX, DI + VPBROADCASTQ BX, Y1 + VPBROADCASTQ SI, Y2 + +loop_32: + VMOVDQU (CX), Y3 + ADDQ $0x20, CX + VPMULLQ Y3, Y2, Y3 + VPADDQ Y3, Y0, Y0 + VPROLQ $0x1f, Y0, Y0 + VPMULLQ Y0, Y1, Y0 + CMPQ CX, DI + JNE loop_32 + VMOVDQU Y0, (AX) + VZEROUPPER + MOVQ DX, ret+32(FP) + RET diff --git a/xxhash_other.go b/xxhash_other.go index 073ae02..ca3407f 100644 --- a/xxhash_other.go +++ b/xxhash_other.go @@ -64,7 +64,7 @@ func Sum64(b []byte) uint64 { } func writeBlocks(d *Digest, b []byte) int { - v1, v2, v3, v4 := d.v1, d.v2, d.v3, d.v4 + v1, v2, v3, v4 := d.s[0], d.s[1], d.s[2], d.s[3] n := len(b) for len(b) >= 32 { v1 = round(v1, u64(b[0:8:len(b)])) @@ -73,6 +73,6 @@ func writeBlocks(d *Digest, b []byte) int { v4 = round(v4, u64(b[24:32:len(b)])) b = b[32:len(b):len(b)] } - d.v1, d.v2, d.v3, d.v4 = v1, v2, v3, v4 + d.s[0], d.s[1], d.s[2], d.s[3] = v1, v2, v3, v4 return n - len(b) } From 53f0391da346e68bd28455ee100479d450629856 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Wed, 8 May 2024 15:41:03 +0200 Subject: [PATCH 03/16] rework Digest.mem to be passed as side array MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ``` > benchstat /tmp/{old,new,extra}.results goos: linux goarch: amd64 pkg: github.com/cespare/xxhash/v2 cpu: AMD Ryzen 9 7950X 16-Core Processor │ no avx512 │ avx512 │ avx512+extra │ │ sec/op │ sec/op vs base │ sec/op vs base │ DigestBytes/4B 9.358n ± 2% 9.377n ± 2% ~ (p=0.481 n=10) 5.873n ± 5% -37.24% (p=0.000 n=10) DigestBytes/16B 11.485n ± 3% 11.485n ± 1% ~ (p=0.469 n=10) 7.292n ± 5% -36.51% (p=0.000 n=10) DigestBytes/100B 15.97n ± 2% 20.41n ± 3% +27.80% (p=0.000 n=10) 20.31n ± 3% +27.18% (p=0.000 n=10) DigestBytes/4KB 212.4n ± 2% 167.7n ± 3% -21.09% (p=0.000 n=10) 163.5n ± 3% -23.02% (p=0.000 n=10) DigestBytes/10MB 493.2µ ± 3% 380.3µ ± 2% -22.90% (p=0.000 n=10) 375.1µ ± 2% -23.94% (p=0.000 n=10) geomean 178.2n 169.6n -4.87% 139.8n -21.57% │ no avx512 │ avx512 │ avx512+extra │ │ B/s │ B/s vs base │ B/s vs base │ DigestBytes/4B 407.6Mi ± 2% 406.8Mi ± 2% ~ (p=0.481 n=10) 649.6Mi ± 5% +59.35% (p=0.000 n=10) DigestBytes/16B 1.298Gi ± 3% 1.298Gi ± 1% ~ (p=0.529 n=10) 2.044Gi ± 5% +57.49% (p=0.000 n=10) DigestBytes/100B 5.831Gi ± 2% 4.563Gi ± 3% -21.75% (p=0.000 n=10) 4.586Gi ± 3% -21.35% (p=0.000 n=10) DigestBytes/4KB 17.54Gi ± 2% 22.22Gi ± 3% +26.72% (p=0.000 n=10) 22.78Gi ± 3% +29.90% (p=0.000 n=10) DigestBytes/10MB 18.88Gi ± 2% 24.49Gi ± 2% +29.69% (p=0.000 n=10) 24.83Gi ± 2% +31.48% (p=0.000 n=10) geomean 3.979Gi 4.183Gi +5.12% 5.074Gi +27.51% ``` --- gen/avx512.go | 54 +++++++++++++++++++++++++------------------ xxhash.go | 47 ++++++++++++++++++------------------- xxhash_amd64.s | 49 ++++++++++++++++++++++----------------- xxhash_arm64.s | 6 ++--- xxhash_asm_amd64.go | 20 ++++++++-------- xxhash_asm_arm64.go | 14 ++++++++++- xxhash_avx512_amd64.s | 44 ++++++++++++++++++++--------------- xxhash_other.go | 28 ++++++++++++++-------- 8 files changed, 152 insertions(+), 110 deletions(-) diff --git a/gen/avx512.go b/gen/avx512.go index 3689c33..68058a6 100644 --- a/gen/avx512.go +++ b/gen/avx512.go @@ -28,32 +28,29 @@ func mergeRound(h /*inout*/, v /*in-destroy*/, p1, p2, p4 reg.GPVirtual) { ADDQ(p4, h) } +func round(state /*inout*/, p, yprime1, yprime2 reg.Register) { + temp := YMM() + VMOVDQU(Mem{Base: p}, temp) + VPMULLQ(temp, yprime2, temp) + VPADDQ(temp, state, state) + VPROLQ(Imm(31), state, state) + VPMULLQ(state, yprime1, state) +} + // blockLoop handles 32 bytes at a time in one YMM register. +// it assume n is 32 bytes or more. // state represent v1, v2, v3, v4 as 4 × uint64. -func blockLoop(state /*inout*/, p /*inout*/, n, p1, p2, processed /*out-optional*/ reg.Register) { +func blockLoop(state /*inout*/, p /*inout*/, n, yprime1, yprime2 reg.Register) { endp := GP64() MOVL(U32(31), endp.As32()) ANDNQ(n, endp, endp) - if processed != nil { - MOVQ(endp, processed) - } ADDQ(p, endp) - yprime1 := YMM() - VPBROADCASTQ(p1, yprime1) - yprime2 := YMM() - VPBROADCASTQ(p2, yprime2) - Label("loop_32") { // main block loop - temp := YMM() - VMOVDQU(Mem{Base: p}, temp) + round(state, p, yprime1, yprime2) ADDQ(Imm(32), p) - VPMULLQ(temp, yprime2, temp) - VPADDQ(temp, state, state) - VPROLQ(Imm(31), state, state) - VPMULLQ(state, yprime1, state) CMPQ(p, endp) JNE(LabelRef("loop_32")) @@ -68,7 +65,7 @@ func sum64() { DATA(16, U64(0)) DATA(24, U64(-prime1)) - TEXT("sum64avx512", NOSPLIT|NOFRAME, "func(b []byte) uint64") + TEXT("sum64Avx512", NOSPLIT|NOFRAME, "func(b []byte) uint64") p := Load(Param("b").Base(), GP64()) n := Load(Param("b").Len(), GP64()) @@ -95,7 +92,11 @@ func sum64() { state := YMM() VMOVDQU(initStateAvx512, state) - blockLoop(state, p, n, p1, p2, nil) + yprime1, yprime2 := YMM(), YMM() + VPBROADCASTQ(p1, yprime1) + VPBROADCASTQ(p2, yprime2) + + blockLoop(state, p, n, yprime1, yprime2) // This interleave two things: extracting v1,2,3,4 from state and computing h. v1, v2, v3, v4, temp := GP64(), GP64(), GP64(), GP64(), GP64() @@ -212,24 +213,31 @@ func sum64() { } func writeBlocks() { - TEXT("writeBlocksAvx512", NOSPLIT|NOFRAME, "func(d *[4]uint64, b []byte) int") + TEXT("writeBlocksAvx512", NOSPLIT|NOFRAME, "func(d *[4]uint64, extra *[32]byte, b []byte)") d := Load(Param("d"), GP64()) + extra := Load(Param("extra"), GP64()) p := Load(Param("b").Base(), GP64()) n := Load(Param("b").Len(), GP64()) state := YMM() VMOVDQU(Mem{Base: d, Disp: 0}, state) - p1, p2 := GP64(), GP64() + p1, p2, yprime1, yprime2 := GP64(), GP64(), YMM(), YMM() MOVQ(Imm(prime1), p1) + VPBROADCASTQ(p1, yprime1) MOVQ(Imm(prime2), p2) + VPBROADCASTQ(p2, yprime2) + + TESTQ(extra, extra) + JZ(LabelRef("skip_extra")) + { + round(state, extra, yprime1, yprime2) + } + Label("skip_extra") - processed := GP64() - blockLoop(state, p, n, p1, p2, processed) + blockLoop(state, p, n, yprime1, yprime2) VMOVDQU(state, Mem{Base: d, Disp: 0}) VZEROUPPER() - - Store(processed, ReturnIndex(0)) RET() } diff --git a/xxhash.go b/xxhash.go index e3ed38f..dd188e9 100644 --- a/xxhash.go +++ b/xxhash.go @@ -30,7 +30,7 @@ type Digest struct { s [4]uint64 total uint64 mem [32]byte - n int // how much of mem is used + n uint8 // how much of mem is used } // New creates a new Digest with a zero seed. @@ -73,35 +73,32 @@ func (d *Digest) Write(b []byte) (n int, err error) { n = len(b) d.total += uint64(n) - memleft := d.mem[d.n&(len(d.mem)-1):] - - if d.n+n < 32 { - // This new data doesn't even fill the current block. - copy(memleft, b) - d.n += n - return - } - - if d.n > 0 { - // Finish off the partial block. - c := copy(memleft, b) - d.s[0] = round(d.s[0], u64(d.mem[0:8])) - d.s[1] = round(d.s[1], u64(d.mem[8:16])) - d.s[2] = round(d.s[2], u64(d.mem[16:24])) - d.s[3] = round(d.s[3], u64(d.mem[24:32])) - b = b[c:] + var extra *[32]byte + if d.n != 0 { + // there is data already in mem, append to it. + added := copy(d.mem[d.n:], b) + b = b[added:] + d.n += uint8(added) + if uint(d.n) < uint(len(d.mem)) { + // not enough data to hash. + return + } + extra = &d.mem d.n = 0 } if len(b) >= 32 { // One or more full blocks left. - nw := writeBlocks(d, b) - b = b[nw:] + writeBlocks(d, extra, b) + b = b[uint(len(b))&^31:] + } else if extra != nil { + // we don't have enough data to fill b but we have an extra. + // write blocks must never be called with len(b) < 32 so pass extra as b. + writeBlocks(d, nil, extra[:]) } // Store any remaining partial block. - copy(d.mem[:], b) - d.n = len(b) + d.n = uint8(copy(d.mem[:], b)) return } @@ -139,7 +136,7 @@ func (d *Digest) Sum64() uint64 { h += d.total - b := d.mem[:d.n&(len(d.mem)-1)] + b := d.mem[:d.n&uint8(len(d.mem)-1)] for ; len(b) >= 8; b = b[8:] { k1 := round(0, u64(b[:8])) h ^= k1 @@ -179,7 +176,7 @@ func (d *Digest) MarshalBinary() ([]byte, error) { b = appendUint64(b, d.s[3]) b = appendUint64(b, d.total) b = append(b, d.mem[:d.n]...) - b = b[:len(b)+len(d.mem)-d.n] + b = b[:len(b)+len(d.mem)-int(d.n)] return b, nil } @@ -198,7 +195,7 @@ func (d *Digest) UnmarshalBinary(b []byte) error { b, d.s[3] = consumeUint64(b) b, d.total = consumeUint64(b) copy(d.mem[:], b) - d.n = int(d.total % uint64(len(d.mem))) + d.n = uint8(d.total % uint64(len(d.mem))) return nil } diff --git a/xxhash_amd64.s b/xxhash_amd64.s index 7a60a92..3f00db5 100644 --- a/xxhash_amd64.s +++ b/xxhash_amd64.s @@ -40,11 +40,8 @@ IMULQ prime1, acc \ ADDQ prime4, acc -// blockLoop processes as many 32-byte blocks as possible, -// updating v1, v2, v3, and v4. It assumes that there is at least one block -// to process. -#define blockLoop() \ -loop: \ +// round32 perform a 32byte round loading from ptr on v1, v2, v3, v4. +#define round32() \ MOVQ +0(p), x \ round(v1, x) \ MOVQ +8(p), x \ @@ -52,13 +49,20 @@ loop: \ MOVQ +16(p), x \ round(v3, x) \ MOVQ +24(p), x \ - round(v4, x) \ - ADDQ $32, p \ - CMPQ p, end \ + round(v4, x) + +// blockLoop processes as many 32-byte blocks as possible, +// updating v1, v2, v3, and v4. It assumes that there is at least one block +// to process. +#define blockLoop() \ +loop: \ + round32() \ + ADDQ $32, p \ + CMPQ p, end \ JLE loop // func sum64(b []byte) uint64 -TEXT ·sum64scallar(SB), NOSPLIT|NOFRAME, $0-32 +TEXT ·sum64Scalar(SB), NOSPLIT|NOFRAME, $0-32 // Load fixed primes. MOVQ ·primes+0(SB), prime1 MOVQ ·primes+8(SB), prime2 @@ -173,18 +177,12 @@ finalize: MOVQ h, ret+24(FP) RET -// func writeBlocksScallar(d *Digest, b []byte) int -TEXT ·writeBlocksScallar(SB), NOSPLIT|NOFRAME, $0-40 +// func writeBlocksScalar(d *Digest, extra *[32]byte, b []byte) +TEXT ·writeBlocksScalar(SB), NOSPLIT|NOFRAME, $0-40 // Load fixed primes needed for round. MOVQ ·primes+0(SB), prime1 MOVQ ·primes+8(SB), prime2 - // Load slice. - MOVQ b_base+8(FP), p - MOVQ b_len+16(FP), n - LEAQ (p)(n*1), end - SUBQ $32, end - // Load vN from d. MOVQ s+0(FP), d MOVQ 0(d), v1 @@ -192,6 +190,19 @@ TEXT ·writeBlocksScallar(SB), NOSPLIT|NOFRAME, $0-40 MOVQ 16(d), v3 MOVQ 24(d), v4 + // Handle extra + MOVQ extra+8(FP), p + TESTQ p, p + JZ noExtra + round32() +noExtra: + + // Load slice. + MOVQ b_base+16(FP), p + MOVQ b_len+24(FP), n + LEAQ (p)(n*1), end + SUBQ $32, end + // We don't need to check the loop condition here; this function is // always called with at least one block of data to process. blockLoop() @@ -202,8 +213,4 @@ TEXT ·writeBlocksScallar(SB), NOSPLIT|NOFRAME, $0-40 MOVQ v3, 16(d) MOVQ v4, 24(d) - // The number of bytes written is p minus the old base pointer. - SUBQ b_base+8(FP), p - MOVQ p, ret+32(FP) - RET diff --git a/xxhash_arm64.s b/xxhash_arm64.s index 7e3145a..f03a3e5 100644 --- a/xxhash_arm64.s +++ b/xxhash_arm64.s @@ -161,8 +161,8 @@ finalize: MOVD h, ret+24(FP) RET -// func writeBlocks(d *Digest, b []byte) int -TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40 +// func writeBlocksArm64(d *Digest, b []byte) +TEXT ·writeBlocksArm64(SB), NOSPLIT|NOFRAME, $0-32 LDP ·primes+0(SB), (prime1, prime2) // Load state. Assume v[1-4] are stored contiguously. @@ -178,6 +178,4 @@ TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40 STP (v1, v2), 0(digest) STP (v3, v4), 16(digest) - BIC $31, n - MOVD n, ret+32(FP) RET diff --git a/xxhash_asm_amd64.go b/xxhash_asm_amd64.go index 898b9b3..a0faa63 100644 --- a/xxhash_asm_amd64.go +++ b/xxhash_asm_amd64.go @@ -12,26 +12,28 @@ var useAvx512 = cpuid.CPU.Supports(cpuid.AVX, cpuid.AVX2, cpuid.AVX512DQ, cpuid. // Sum64 computes the 64-bit xxHash digest of b with a zero seed. func Sum64(b []byte) uint64 { if useAvx512 { - return sum64avx512(b) + return sum64Avx512(b) } - return sum64scallar(b) + return sum64Scalar(b) } //go:noescape -func sum64scallar(b []byte) uint64 +func sum64Scalar(b []byte) uint64 //go:noescape -func sum64avx512(b []byte) uint64 +func sum64Avx512(b []byte) uint64 -func writeBlocks(d *Digest, b []byte) int { +// extra is a first block before b, it may be nil then skip it. +func writeBlocks(d *Digest, extra *[32]byte, b []byte) { if useAvx512 { - return writeBlocksAvx512(&d.s, b) + writeBlocksAvx512(&d.s, extra, b) + return } - return writeBlocksScallar(d, b) + writeBlocksScalar(d, nil, b) } //go:noescape -func writeBlocksAvx512(d *[4]uint64, b []byte) int +func writeBlocksAvx512(d *[4]uint64, extra *[32]byte, b []byte) //go:noescape -func writeBlocksScallar(d *Digest, b []byte) int +func writeBlocksScalar(d *Digest, extra *[32]byte, b []byte) diff --git a/xxhash_asm_arm64.go b/xxhash_asm_arm64.go index ede1693..06e89a0 100644 --- a/xxhash_asm_arm64.go +++ b/xxhash_asm_arm64.go @@ -10,5 +10,17 @@ var useAvx512 = false //go:noescape func Sum64(b []byte) uint64 +// extra is a first block before b, it may be nil then skip it. +func writeBlocks(d *Digest, extra *[32]byte, b []byte) { + if extra != nil { + // FIXME: handle that logic in ASM, *someone* was lazy and didn't + // cared to learn the arm64 p9 syntax. + // At least this is hopefully on par with how fast the software impl + // it used to be. + writeBlocksArm64(d, extra[:]) + } + writeBlocksArm64(d, b) +} + //go:noescape -func writeBlocks(d *Digest, b []byte) int +func writeBlocksArm64(d *Digest, b []byte) diff --git a/xxhash_avx512_amd64.s b/xxhash_avx512_amd64.s index 7e0665a..c779a24 100644 --- a/xxhash_avx512_amd64.s +++ b/xxhash_avx512_amd64.s @@ -8,9 +8,9 @@ DATA ·initWideAvx512<>+16(SB)/8, $0x0000000000000000 DATA ·initWideAvx512<>+24(SB)/8, $0x61c8864e7a143579 GLOBL ·initWideAvx512<>(SB), NOSPLIT|NOPTR, $32 -// func sum64avx512(b []byte) uint64 +// func sum64Avx512(b []byte) uint64 // Requires: AVX, AVX2, AVX512DQ, AVX512F, AVX512VL, BMI -TEXT ·sum64avx512(SB), NOSPLIT|NOFRAME, $0-32 +TEXT ·sum64Avx512(SB), NOSPLIT|NOFRAME, $0-32 MOVQ b_base+0(FP), AX MOVQ b_len+8(FP), CX MOVQ $0x9e3779b185ebca87, DX @@ -28,19 +28,19 @@ TEXT ·sum64avx512(SB), NOSPLIT|NOFRAME, $0-32 CMPQ CX, $0x1f JBE loop_8 VMOVDQU ·initWideAvx512<>+0(SB), Y0 + VPBROADCASTQ DX, Y1 + VPBROADCASTQ BX, Y2 MOVL $0x0000001f, R9 ANDNQ CX, R9, R9 ADDQ AX, R9 - VPBROADCASTQ DX, Y1 - VPBROADCASTQ BX, Y2 loop_32: VMOVDQU (AX), Y3 - ADDQ $0x20, AX VPMULLQ Y3, Y2, Y3 VPADDQ Y3, Y0, Y0 VPROLQ $0x1f, Y0, Y0 VPMULLQ Y0, Y1, Y0 + ADDQ $0x20, AX CMPQ AX, R9 JNE loop_32 VMOVQ X0, R10 @@ -151,32 +151,40 @@ zero: MOVQ R9, ret+24(FP) RET -// func writeBlocksAvx512(d *[4]uint64, b []byte) int +// func writeBlocksAvx512(d *[4]uint64, extra *[32]byte, b []byte) // Requires: AVX, AVX2, AVX512DQ, AVX512F, AVX512VL, BMI TEXT ·writeBlocksAvx512(SB), NOSPLIT|NOFRAME, $0-40 MOVQ d+0(FP), AX - MOVQ b_base+8(FP), CX - MOVQ b_len+16(FP), DX + MOVQ extra+8(FP), CX + MOVQ b_base+16(FP), DX + MOVQ b_len+24(FP), BX VMOVDQU (AX), Y0 - MOVQ $0x9e3779b185ebca87, BX + MOVQ $0x9e3779b185ebca87, SI + VPBROADCASTQ SI, Y1 MOVQ $0xc2b2ae3d27d4eb4f, SI - MOVL $0x0000001f, DI - ANDNQ DX, DI, DI - MOVQ DI, DX - ADDQ CX, DI - VPBROADCASTQ BX, Y1 VPBROADCASTQ SI, Y2 + TESTQ CX, CX + JZ skip_extra + VMOVDQU (CX), Y3 + VPMULLQ Y3, Y2, Y3 + VPADDQ Y3, Y0, Y0 + VPROLQ $0x1f, Y0, Y0 + VPMULLQ Y0, Y1, Y0 + +skip_extra: + MOVL $0x0000001f, CX + ANDNQ BX, CX, CX + ADDQ DX, CX loop_32: - VMOVDQU (CX), Y3 - ADDQ $0x20, CX + VMOVDQU (DX), Y3 VPMULLQ Y3, Y2, Y3 VPADDQ Y3, Y0, Y0 VPROLQ $0x1f, Y0, Y0 VPMULLQ Y0, Y1, Y0 - CMPQ CX, DI + ADDQ $0x20, DX + CMPQ DX, CX JNE loop_32 VMOVDQU Y0, (AX) VZEROUPPER - MOVQ DX, ret+32(FP) RET diff --git a/xxhash_other.go b/xxhash_other.go index ca3407f..b4a536f 100644 --- a/xxhash_other.go +++ b/xxhash_other.go @@ -63,16 +63,26 @@ func Sum64(b []byte) uint64 { return h } -func writeBlocks(d *Digest, b []byte) int { +func writeBlocks(d *Digest, extra *[32]byte, b []byte) { v1, v2, v3, v4 := d.s[0], d.s[1], d.s[2], d.s[3] - n := len(b) - for len(b) >= 32 { - v1 = round(v1, u64(b[0:8:len(b)])) - v2 = round(v2, u64(b[8:16:len(b)])) - v3 = round(v3, u64(b[16:24:len(b)])) - v4 = round(v4, u64(b[24:32:len(b)])) - b = b[32:len(b):len(b)] + var s []byte + if extra != nil { + s = extra[:] + } else { + s = b + } + for len(s) >= 32 { + for len(s) >= 32 { + v1 = round(v1, u64(s[0:8:len(s)])) + v2 = round(v2, u64(s[8:16:len(s)])) + v3 = round(v3, u64(s[16:24:len(s)])) + v4 = round(v4, u64(s[24:32:len(s)])) + s = s[32:len(s):len(s)] + } + if extra != nil { + s = b + extra = nil + } } d.s[0], d.s[1], d.s[2], d.s[3] = v1, v2, v3, v4 - return n - len(b) } From 4dc0b915eef760f1066887bb8ba07d907d783130 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Tue, 18 Jun 2024 21:27:42 +0200 Subject: [PATCH 04/16] move generation to it's own submodule Keeps avo out of the dependency tree. --- gen/avx512.go | 5 ++++ gen/go.mod | 13 ++++++++++ gen/go.sum | 10 ++++++++ go.mod | 4 +-- go.sum | 59 ++------------------------------------------- xxhash_asm_amd64.go | 2 +- 6 files changed, 33 insertions(+), 60 deletions(-) create mode 100644 gen/go.mod create mode 100644 gen/go.sum diff --git a/gen/avx512.go b/gen/avx512.go index 68058a6..34324ed 100644 --- a/gen/avx512.go +++ b/gen/avx512.go @@ -1,6 +1,8 @@ package main import ( + "os" + "github.com/cespare/xxhash/v2" . "github.com/mmcloughlin/avo/build" . "github.com/mmcloughlin/avo/operand" @@ -242,6 +244,9 @@ func writeBlocks() { } func main() { + if err := os.Chdir(".."); err != nil { + panic(err) + } sum64() writeBlocks() Generate() diff --git a/gen/go.mod b/gen/go.mod new file mode 100644 index 0000000..8fc298d --- /dev/null +++ b/gen/go.mod @@ -0,0 +1,13 @@ +module github.com/cespare/xxhash/v2/gen + +go 1.23 + +require ( + github.com/cespare/xxhash/v2 v2.3.0 + github.com/mmcloughlin/avo v0.6.0 +) + +require ( + golang.org/x/mod v0.14.0 // indirect + golang.org/x/tools v0.16.1 // indirect +) diff --git a/gen/go.sum b/gen/go.sum new file mode 100644 index 0000000..b63110c --- /dev/null +++ b/gen/go.sum @@ -0,0 +1,10 @@ +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/mmcloughlin/avo v0.6.0 h1:QH6FU8SKoTLaVs80GA8TJuLNkUYl4VokHKlPhVDg4YY= +github.com/mmcloughlin/avo v0.6.0/go.mod h1:8CoAGaCSYXtCPR+8y18Y9aB/kxb8JSS6FRI7mSkvD+8= +golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= +golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE= +golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/tools v0.16.1 h1:TLyB3WofjdOEepBHAU20JdNC1Zbg87elYofWYAY5oZA= +golang.org/x/tools v0.16.1/go.mod h1:kYVVN6I1mBNoB1OX+noeBjbRk4IUEPa7JJ+TJMEooJ0= diff --git a/go.mod b/go.mod index e3385f4..9885116 100644 --- a/go.mod +++ b/go.mod @@ -3,6 +3,6 @@ module github.com/cespare/xxhash/v2 go 1.11 require ( - github.com/klauspost/cpuid/v2 v2.2.7 - github.com/mmcloughlin/avo v0.6.0 + github.com/klauspost/cpuid/v2 v2.2.8 + golang.org/x/sys v0.15.0 // indirect ) diff --git a/go.sum b/go.sum index 1168a1b..01bd722 100644 --- a/go.sum +++ b/go.sum @@ -1,60 +1,5 @@ -github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM= -github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= -github.com/mmcloughlin/avo v0.6.0 h1:QH6FU8SKoTLaVs80GA8TJuLNkUYl4VokHKlPhVDg4YY= -github.com/mmcloughlin/avo v0.6.0/go.mod h1:8CoAGaCSYXtCPR+8y18Y9aB/kxb8JSS6FRI7mSkvD+8= -github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= -golang.org/x/arch v0.6.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc= -golang.org/x/crypto v0.16.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4= -golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= -golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= -golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= -golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk= -golang.org/x/net v0.19.0/go.mod h1:CfAk/cbD4CthTvqiEl8NpboMuiuOYsAr/7NOjZJtv1U= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= -golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE= -golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +github.com/klauspost/cpuid/v2 v2.2.8 h1:+StwCXwm9PdpiEkPyzBXIy+M9KUb4ODm0Zarf1kS5BM= +github.com/klauspost/cpuid/v2 v2.2.8/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc= golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= -golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo= -golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU= -golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= -golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= -golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= -golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58= -golang.org/x/tools v0.16.1 h1:TLyB3WofjdOEepBHAU20JdNC1Zbg87elYofWYAY5oZA= -golang.org/x/tools v0.16.1/go.mod h1:kYVVN6I1mBNoB1OX+noeBjbRk4IUEPa7JJ+TJMEooJ0= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= diff --git a/xxhash_asm_amd64.go b/xxhash_asm_amd64.go index a0faa63..54a2b91 100644 --- a/xxhash_asm_amd64.go +++ b/xxhash_asm_amd64.go @@ -1,7 +1,7 @@ //go:build amd64 && !appengine && gc && !purego // +build amd64,!appengine,gc,!purego -//go:generate go run -tags purego ./gen -out xxhash_avx512_amd64.s +//go:generate sh -c "cd gen && go run -tags purego . -out xxhash_avx512_amd64.s" package xxhash From 24dee9091bbfa992879dacb3cb38851d7d698c92 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Tue, 18 Jun 2024 21:27:59 +0200 Subject: [PATCH 05/16] tweak CPUID so AVX512 impl only runs on amd --- xxhash_asm_amd64.go | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/xxhash_asm_amd64.go b/xxhash_asm_amd64.go index 54a2b91..c8465a3 100644 --- a/xxhash_asm_amd64.go +++ b/xxhash_asm_amd64.go @@ -7,7 +7,20 @@ package xxhash import "github.com/klauspost/cpuid/v2" -var useAvx512 = cpuid.CPU.Supports(cpuid.AVX, cpuid.AVX2, cpuid.AVX512DQ, cpuid.AVX512F, cpuid.AVX512VL, cpuid.BMI1) +var useAvx512 = cpuid.CPU.Supports( + cpuid.AVX, + cpuid.AVX2, + cpuid.AVX512DQ, + cpuid.AVX512F, + cpuid.AVX512VL, + cpuid.BMI1, + +// Today, vectorized 64 bits integer multiples positively sucks on intel, +// with ILP a single scalar unit is multiple times faster. +// This means sometime we wont be using the AVX512 when under virtualization +// because vendor will be the hypervisor, but in my experience that is rare. +// Most virtualization setups defaults to reporting the vendorid of the host. +) && cpuid.CPU.IsVendor(cpuid.AMD) // Sum64 computes the 64-bit xxHash digest of b with a zero seed. func Sum64(b []byte) uint64 { From 0108fb04933e38abc34010c69077a62434a7a3b1 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Tue, 18 Jun 2024 21:44:40 +0200 Subject: [PATCH 06/16] clarify useAvx512 in arm64 --- xxhash_asm_arm64.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/xxhash_asm_arm64.go b/xxhash_asm_arm64.go index 06e89a0..0972211 100644 --- a/xxhash_asm_arm64.go +++ b/xxhash_asm_arm64.go @@ -3,7 +3,7 @@ package xxhash -var useAvx512 = false +var useAvx512 = false // used in tests // Sum64 computes the 64-bit xxHash digest of b with a zero seed. // From 95cabeb7d88acaabab4ef8c47a165c82c46e8ea1 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Tue, 18 Jun 2024 22:33:50 +0200 Subject: [PATCH 07/16] simplify extra handling in generic writeBlocks --- xxhash_other.go | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/xxhash_other.go b/xxhash_other.go index b4a536f..67395cd 100644 --- a/xxhash_other.go +++ b/xxhash_other.go @@ -71,18 +71,18 @@ func writeBlocks(d *Digest, extra *[32]byte, b []byte) { } else { s = b } +reHash: for len(s) >= 32 { - for len(s) >= 32 { - v1 = round(v1, u64(s[0:8:len(s)])) - v2 = round(v2, u64(s[8:16:len(s)])) - v3 = round(v3, u64(s[16:24:len(s)])) - v4 = round(v4, u64(s[24:32:len(s)])) - s = s[32:len(s):len(s)] - } - if extra != nil { - s = b - extra = nil - } + v1 = round(v1, u64(s[0:8:len(s)])) + v2 = round(v2, u64(s[8:16:len(s)])) + v3 = round(v3, u64(s[16:24:len(s)])) + v4 = round(v4, u64(s[24:32:len(s)])) + s = s[32:len(s):len(s)] + } + if extra != nil { + s = b + extra = nil + goto reHash } d.s[0], d.s[1], d.s[2], d.s[3] = v1, v2, v3, v4 } From 0a6336cd121a3a45368eafd3779fc743024ce960 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Thu, 20 Jun 2024 06:43:28 +0200 Subject: [PATCH 08/16] implement slide sum for amd64 fallback --- gen/avx512.go | 7 +- gen/main.go | 13 + gen/slide.go | 172 +++++ xxhash_asm_amd64.go | 3 + xxhash_avx512_amd64.s | 2 +- xxhash_slide.go | 1482 +++++++++++++++++++++++++++++++++++++++++ 6 files changed, 1672 insertions(+), 7 deletions(-) create mode 100644 gen/main.go create mode 100644 gen/slide.go create mode 100644 xxhash_slide.go diff --git a/gen/avx512.go b/gen/avx512.go index 34324ed..4bb9f00 100644 --- a/gen/avx512.go +++ b/gen/avx512.go @@ -1,8 +1,6 @@ package main import ( - "os" - "github.com/cespare/xxhash/v2" . "github.com/mmcloughlin/avo/build" . "github.com/mmcloughlin/avo/operand" @@ -243,10 +241,7 @@ func writeBlocks() { RET() } -func main() { - if err := os.Chdir(".."); err != nil { - panic(err) - } +func avx512() { sum64() writeBlocks() Generate() diff --git a/gen/main.go b/gen/main.go new file mode 100644 index 0000000..d9d42e7 --- /dev/null +++ b/gen/main.go @@ -0,0 +1,13 @@ +package main + +import "os" + +func main() { + if err := os.Chdir(".."); err != nil { + panic(err) + } + avx512() + if err := slide(); err != nil { + panic(err) + } +} diff --git a/gen/slide.go b/gen/slide.go new file mode 100644 index 0000000..a40d219 --- /dev/null +++ b/gen/slide.go @@ -0,0 +1,172 @@ +package main + +import ( + "bytes" + "fmt" + "os" +) + +const sumSlideSize = 127 +const path = "xxhash_slide.go" + +func slide() error { + w := &bytes.Buffer{} + + fmt.Fprintf(w, `package xxhash + +// Generated by gen/slide.go. DO NOT EDIT. + +const slideLength = %d + +// Handles length 0-%d bytes using sum slides. +func slide(b []byte) uint64 { + // This function use sum slides, theses are straight unrolled pieces of code which compute hashes, with middle jumps. + // Each do not contain any conditions to make them trivial for the CPU to parse and never cause any pipeline flushes after the first jump table. + // We need 32 different slides to cover each offset into the 32 block size. The trailing 32 bytes are handled by their own slides which are shared and reused by the higher slides. + // The trailing 32 bytes slides are reused for each offset. The CPUs we care about can always correctly read unconditional jumps without causing a pipeline flush. + + // This function is written more like an optimized assembly routine, except we trick the compiler into generating good code by generating the slide ourself. + // Using the go compiler make the call overhead cheaper since it will use the unstable ABIInternal passing through registers. + // They are also extremely effective when hashing multiple values of the same size back to back. + // Assumptions of this strategy: + // - All the state except b's array will be correctly register allocated. + // It probably generate unnecessary MOVs but the critical path includes LAT3 multiplies for each block, so there is plenty of time to dispatch renames. + // - The compiler is basic block based and will do a good enough job at layout. This is true for some the go compiler, llvm and some of gcc. + // This means I make very liberal use of goto, they shouldn't be red as JMPs but abstract basic blocks links. + + // Setups variables here since go doesn't want use to do dangerous gotos. + v1 := prime1 + v1 += prime2 + v2 := prime2 + v3 := uint64(0) + v4 := prime1 + v4 = -v4 + h := prime5 + n := uint64(len(b)) + + // Jump table to various positions in the slide, this setups proofs for bounds checks. + // From then on it need to make sure to maintain constance in the length of b. + switch len(b) { + case 0: + // Handle this appart because it can be completely folded. + h += n + h ^= h >> 33 + h *= prime2 + h ^= h >> 29 + h *= prime3 + h ^= h >> 32 + return h +`, sumSlideSize, sumSlideSize) + for i := 1; i <= sumSlideSize; i++ { + fmt.Fprintf(w, ` case %d: + goto sz_%d +`, i, i) + } + w.WriteString(` default: + panic("unreachable; slide overflow") + } + + // Theses are the main slides, they handle 32 bytes 4 × 8 bytes at a time using ILP. +`) + // POTENTIAL OPTIMIZATION: We could use a single slide and shuffle v{1,2,3,4} based on offset. This would make setup and transition into trailer more expensive but codesize would be smaller and some i-cache reuse would be certain to happen for anything touching it. + + for k := range 32 { + i := sumSlideSize - k + for ; i >= 32; i -= 32 { + fmt.Fprintf(w, `sz_%d: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +`, i) + // POTENTIAL OPTIMIZATION: b[32:] creates an addition to bump the pointer which means the address dependency on the memory loads is not resolved before the jmp table. I know two fixes: + // - change b to a pointer to the end of the slice and subtract the total offset. I don't know how to do this in pure go. + // - don't bother reusing the slides, this means each load instruction can hardcode the offset. Make the code significantly bigger and i-cache worst, altho I didn't tried it. + } + w.WriteString(` h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +`) + if i != 0 { // Avoid « label sz_0 defined and not used », case 0 shortcuts with a precomputed value. + fmt.Fprintf(w, "sz_%d:\n", i) + } + fmt.Fprintf(w, ` h += n + goto sz_%dl + +`, i) + } + + w.WriteString(" // Theses are 8 bytes block trailing slides.\n") + for k := range 8 { + i := 31 - k + for ; i >= 8; i -= 8 { + fmt.Fprintf(w, `sz_%dl: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +`, i) + } + fmt.Fprintf(w, `goto sz_%dl + +`, i) + } + + w.WriteString(" // Theses are the 4 bytes trailing slides.\n") + for k := range 4 { + i := 7 - k + fmt.Fprintf(w, `sz_%dl: + h ^= uint64(u32(b[:4])) * prime1 + h = rol23(h)*prime2 + prime3 + b = b[4:] + goto sz_%dl + +`, i, i-4) + } + + w.WriteString(" // This is the 1 bytes trailing slide.\n") + for i := 4; i > 1; { + i-- + fmt.Fprintf(w, `sz_%dl: + h ^= uint64(b[0]) * prime5 + h = rol11(h) * prime1 + b = b[1:] + +`, i) + } + // Carefull here, the loop above fallthrough to zero. + + w.WriteString(` // Finally the terminator. +sz_0l: + h ^= h >> 33 + h *= prime2 + h ^= h >> 29 + h *= prime3 + h ^= h >> 32 + + return h +} +`) + + f, err := os.Create(path) + if err != nil { + return err + } + _, err = w.WriteTo(f) + if err != nil { + os.Remove(path) + return err + } + err = f.Close() + if err != nil { + os.Remove(path) + return err + } + + return nil +} diff --git a/xxhash_asm_amd64.go b/xxhash_asm_amd64.go index c8465a3..531fa56 100644 --- a/xxhash_asm_amd64.go +++ b/xxhash_asm_amd64.go @@ -24,6 +24,9 @@ var useAvx512 = cpuid.CPU.Supports( // Sum64 computes the 64-bit xxHash digest of b with a zero seed. func Sum64(b []byte) uint64 { + if len(b) <= slideLength { + return slide(b) + } if useAvx512 { return sum64Avx512(b) } diff --git a/xxhash_avx512_amd64.s b/xxhash_avx512_amd64.s index c779a24..01fd0d6 100644 --- a/xxhash_avx512_amd64.s +++ b/xxhash_avx512_amd64.s @@ -1,4 +1,4 @@ -// Code generated by command: go run avx512.go -out xxhash_avx512_amd64.s. DO NOT EDIT. +// Code generated by command: go run main.go -out xxhash_avx512_amd64.s. DO NOT EDIT. #include "textflag.h" diff --git a/xxhash_slide.go b/xxhash_slide.go new file mode 100644 index 0000000..23cf29a --- /dev/null +++ b/xxhash_slide.go @@ -0,0 +1,1482 @@ +package xxhash + +// Generated by gen/slide.go. DO NOT EDIT. + +const slideLength = 127 + +// Handles length 0-127 bytes using sum slides. +func slide(b []byte) uint64 { + // This function use sum slides, theses are straight unrolled pieces of code which compute hashes, with middle jumps. + // Each do not contain any conditions to make them trivial for the CPU to parse and never cause any pipeline flushes after the first jump table. + // We need 32 different slides to cover each offset into the 32 block size. The trailing 32 bytes are handled by their own slides which are shared and reused by the higher slides. + // The trailing 32 bytes slides are reused for each offset. The CPUs we care about can always correctly read unconditional jumps without causing a pipeline flush. + + // This function is written more like an optimized assembly routine, except we trick the compiler into generating good code by generating the slide ourself. + // Using the go compiler make the call overhead cheaper since it will use the unstable ABIInternal passing through registers. + // They are also extremely effective when hashing multiple values of the same size back to back. + // Assumptions of this strategy: + // - All the state except b's array will be correctly register allocated. + // It probably generate unnecessary MOVs but the critical path includes LAT3 multiplies for each block, so there is plenty of time to dispatch renames. + // - The compiler is basic block based and will do a good enough job at layout. This is true for some the go compiler, llvm and some of gcc. + // This means I make very liberal use of goto, they shouldn't be red as JMPs but abstract basic blocks links. + + // Setups variables here since go doesn't want use to do dangerous gotos. + v1 := prime1 + v1 += prime2 + v2 := prime2 + v3 := uint64(0) + v4 := prime1 + v4 = -v4 + h := prime5 + n := uint64(len(b)) + + // Jump table to various positions in the slide, this setups proofs for bounds checks. + // From then on it need to make sure to maintain constance in the length of b. + switch len(b) { + case 0: + // Handle this appart because it can be completely folded. + h += n + h ^= h >> 33 + h *= prime2 + h ^= h >> 29 + h *= prime3 + h ^= h >> 32 + return h + case 1: + goto sz_1 + case 2: + goto sz_2 + case 3: + goto sz_3 + case 4: + goto sz_4 + case 5: + goto sz_5 + case 6: + goto sz_6 + case 7: + goto sz_7 + case 8: + goto sz_8 + case 9: + goto sz_9 + case 10: + goto sz_10 + case 11: + goto sz_11 + case 12: + goto sz_12 + case 13: + goto sz_13 + case 14: + goto sz_14 + case 15: + goto sz_15 + case 16: + goto sz_16 + case 17: + goto sz_17 + case 18: + goto sz_18 + case 19: + goto sz_19 + case 20: + goto sz_20 + case 21: + goto sz_21 + case 22: + goto sz_22 + case 23: + goto sz_23 + case 24: + goto sz_24 + case 25: + goto sz_25 + case 26: + goto sz_26 + case 27: + goto sz_27 + case 28: + goto sz_28 + case 29: + goto sz_29 + case 30: + goto sz_30 + case 31: + goto sz_31 + case 32: + goto sz_32 + case 33: + goto sz_33 + case 34: + goto sz_34 + case 35: + goto sz_35 + case 36: + goto sz_36 + case 37: + goto sz_37 + case 38: + goto sz_38 + case 39: + goto sz_39 + case 40: + goto sz_40 + case 41: + goto sz_41 + case 42: + goto sz_42 + case 43: + goto sz_43 + case 44: + goto sz_44 + case 45: + goto sz_45 + case 46: + goto sz_46 + case 47: + goto sz_47 + case 48: + goto sz_48 + case 49: + goto sz_49 + case 50: + goto sz_50 + case 51: + goto sz_51 + case 52: + goto sz_52 + case 53: + goto sz_53 + case 54: + goto sz_54 + case 55: + goto sz_55 + case 56: + goto sz_56 + case 57: + goto sz_57 + case 58: + goto sz_58 + case 59: + goto sz_59 + case 60: + goto sz_60 + case 61: + goto sz_61 + case 62: + goto sz_62 + case 63: + goto sz_63 + case 64: + goto sz_64 + case 65: + goto sz_65 + case 66: + goto sz_66 + case 67: + goto sz_67 + case 68: + goto sz_68 + case 69: + goto sz_69 + case 70: + goto sz_70 + case 71: + goto sz_71 + case 72: + goto sz_72 + case 73: + goto sz_73 + case 74: + goto sz_74 + case 75: + goto sz_75 + case 76: + goto sz_76 + case 77: + goto sz_77 + case 78: + goto sz_78 + case 79: + goto sz_79 + case 80: + goto sz_80 + case 81: + goto sz_81 + case 82: + goto sz_82 + case 83: + goto sz_83 + case 84: + goto sz_84 + case 85: + goto sz_85 + case 86: + goto sz_86 + case 87: + goto sz_87 + case 88: + goto sz_88 + case 89: + goto sz_89 + case 90: + goto sz_90 + case 91: + goto sz_91 + case 92: + goto sz_92 + case 93: + goto sz_93 + case 94: + goto sz_94 + case 95: + goto sz_95 + case 96: + goto sz_96 + case 97: + goto sz_97 + case 98: + goto sz_98 + case 99: + goto sz_99 + case 100: + goto sz_100 + case 101: + goto sz_101 + case 102: + goto sz_102 + case 103: + goto sz_103 + case 104: + goto sz_104 + case 105: + goto sz_105 + case 106: + goto sz_106 + case 107: + goto sz_107 + case 108: + goto sz_108 + case 109: + goto sz_109 + case 110: + goto sz_110 + case 111: + goto sz_111 + case 112: + goto sz_112 + case 113: + goto sz_113 + case 114: + goto sz_114 + case 115: + goto sz_115 + case 116: + goto sz_116 + case 117: + goto sz_117 + case 118: + goto sz_118 + case 119: + goto sz_119 + case 120: + goto sz_120 + case 121: + goto sz_121 + case 122: + goto sz_122 + case 123: + goto sz_123 + case 124: + goto sz_124 + case 125: + goto sz_125 + case 126: + goto sz_126 + case 127: + goto sz_127 + default: + panic("unreachable; slide overflow") + } + + // Theses are the main slides, they handle 32 bytes 4 × 8 bytes at a time using ILP. +sz_127: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_95: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_63: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_31: + h += n + goto sz_31l + +sz_126: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_94: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_62: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_30: + h += n + goto sz_30l + +sz_125: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_93: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_61: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_29: + h += n + goto sz_29l + +sz_124: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_92: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_60: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_28: + h += n + goto sz_28l + +sz_123: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_91: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_59: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_27: + h += n + goto sz_27l + +sz_122: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_90: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_58: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_26: + h += n + goto sz_26l + +sz_121: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_89: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_57: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_25: + h += n + goto sz_25l + +sz_120: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_88: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_56: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_24: + h += n + goto sz_24l + +sz_119: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_87: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_55: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_23: + h += n + goto sz_23l + +sz_118: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_86: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_54: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_22: + h += n + goto sz_22l + +sz_117: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_85: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_53: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_21: + h += n + goto sz_21l + +sz_116: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_84: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_52: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_20: + h += n + goto sz_20l + +sz_115: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_83: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_51: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_19: + h += n + goto sz_19l + +sz_114: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_82: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_50: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_18: + h += n + goto sz_18l + +sz_113: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_81: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_49: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_17: + h += n + goto sz_17l + +sz_112: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_80: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_48: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_16: + h += n + goto sz_16l + +sz_111: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_79: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_47: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_15: + h += n + goto sz_15l + +sz_110: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_78: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_46: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_14: + h += n + goto sz_14l + +sz_109: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_77: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_45: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_13: + h += n + goto sz_13l + +sz_108: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_76: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_44: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_12: + h += n + goto sz_12l + +sz_107: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_75: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_43: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_11: + h += n + goto sz_11l + +sz_106: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_74: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_42: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_10: + h += n + goto sz_10l + +sz_105: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_73: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_41: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_9: + h += n + goto sz_9l + +sz_104: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_72: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_40: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_8: + h += n + goto sz_8l + +sz_103: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_71: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_39: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_7: + h += n + goto sz_7l + +sz_102: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_70: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_38: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_6: + h += n + goto sz_6l + +sz_101: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_69: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_37: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_5: + h += n + goto sz_5l + +sz_100: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_68: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_36: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_4: + h += n + goto sz_4l + +sz_99: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_67: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_35: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_3: + h += n + goto sz_3l + +sz_98: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_66: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_34: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_2: + h += n + goto sz_2l + +sz_97: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_65: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_33: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + +sz_1: + h += n + goto sz_1l + +sz_96: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_64: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + +sz_32: + v1 = round(v1, u64(b[0:8])) + v2 = round(v2, u64(b[8:16])) + v3 = round(v3, u64(b[16:24])) + v4 = round(v4, u64(b[24:32])) + b = b[32:] + + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + + h += n + goto sz_0l + + // Theses are 8 bytes block trailing slides. +sz_31l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_23l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_15l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +goto sz_7l + +sz_30l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_22l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_14l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +goto sz_6l + +sz_29l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_21l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_13l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +goto sz_5l + +sz_28l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_20l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_12l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +goto sz_4l + +sz_27l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_19l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_11l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +goto sz_3l + +sz_26l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_18l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_10l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +goto sz_2l + +sz_25l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_17l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_9l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +goto sz_1l + +sz_24l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_16l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +sz_8l: + h ^= round(0, u64(b[0:8])) + h = rol27(h)*prime1 + prime4 + b = b[8:] + +goto sz_0l + + // Theses are the 4 bytes trailing slides. +sz_7l: + h ^= uint64(u32(b[:4])) * prime1 + h = rol23(h)*prime2 + prime3 + b = b[4:] + goto sz_3l + +sz_6l: + h ^= uint64(u32(b[:4])) * prime1 + h = rol23(h)*prime2 + prime3 + b = b[4:] + goto sz_2l + +sz_5l: + h ^= uint64(u32(b[:4])) * prime1 + h = rol23(h)*prime2 + prime3 + b = b[4:] + goto sz_1l + +sz_4l: + h ^= uint64(u32(b[:4])) * prime1 + h = rol23(h)*prime2 + prime3 + b = b[4:] + goto sz_0l + + // This is the 1 bytes trailing slide. +sz_3l: + h ^= uint64(b[0]) * prime5 + h = rol11(h) * prime1 + b = b[1:] + +sz_2l: + h ^= uint64(b[0]) * prime5 + h = rol11(h) * prime1 + b = b[1:] + +sz_1l: + h ^= uint64(b[0]) * prime5 + h = rol11(h) * prime1 + b = b[1:] + + // Finally the terminator. +sz_0l: + h ^= h >> 33 + h *= prime2 + h ^= h >> 29 + h *= prime3 + h ^= h >> 32 + + return h +} From b55cf51e314118e96d6da8be0a918d56eef77ba1 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Thu, 20 Jun 2024 07:23:10 +0200 Subject: [PATCH 09/16] change gen/go.mod to use a more reasonable go.mod version --- gen/go.mod | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gen/go.mod b/gen/go.mod index 8fc298d..8126eab 100644 --- a/gen/go.mod +++ b/gen/go.mod @@ -1,6 +1,6 @@ module github.com/cespare/xxhash/v2/gen -go 1.23 +go 1.22 require ( github.com/cespare/xxhash/v2 v2.3.0 From 506089275923bbc47b8539ea62be623c4096eea2 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Thu, 20 Jun 2024 08:12:04 +0200 Subject: [PATCH 10/16] add very unsubtle bounds hints to the compiler in the slide This is to work around the go compiler's prove limitations. It compiles to nothing but it requires go1.17 since casting to array pointers has only been added in go1.17. --- gen/slide.go | 56 +- xxhash_asm_amd64.go | 13 +- xxhash_not_slide.go | 10 + xxhash_slide.go | 1353 ++++++++++++++++++++++++++----------------- 4 files changed, 865 insertions(+), 567 deletions(-) create mode 100644 xxhash_not_slide.go diff --git a/gen/slide.go b/gen/slide.go index a40d219..47295c6 100644 --- a/gen/slide.go +++ b/gen/slide.go @@ -12,7 +12,10 @@ const path = "xxhash_slide.go" func slide() error { w := &bytes.Buffer{} - fmt.Fprintf(w, `package xxhash + fmt.Fprintf(w, `//go:build go1.17 +// +build go1.17 + +package xxhash // Generated by gen/slide.go. DO NOT EDIT. @@ -33,8 +36,10 @@ func slide(b []byte) uint64 { // It probably generate unnecessary MOVs but the critical path includes LAT3 multiplies for each block, so there is plenty of time to dispatch renames. // - The compiler is basic block based and will do a good enough job at layout. This is true for some the go compiler, llvm and some of gcc. // This means I make very liberal use of goto, they shouldn't be red as JMPs but abstract basic blocks links. + // - The compiler has some SSA passes. + // This is used for all the b_* tricks. - // Setups variables here since go doesn't want use to do dangerous gotos. + // Setup variables here since go doesn't want use to do dangerous gotos. v1 := prime1 v1 += prime2 v2 := prime2 @@ -44,6 +49,16 @@ func slide(b []byte) uint64 { h := prime5 n := uint64(len(b)) + // The go compiler has multiple oversight in the propragation of proofs through Phi nodes. Using array pointers is a very unsubtle hint and compiles to nothing. + // Because we assume the compiler has some low level SSA passes this is otherwise free. + var ( +`, sumSlideSize, sumSlideSize) + for i := 0; i <= sumSlideSize; i++ { + fmt.Fprintf(w, "\t\tb_%d *[%d]byte\n", i, i) + } + + w.WriteString(` ) + // Jump table to various positions in the slide, this setups proofs for bounds checks. // From then on it need to make sure to maintain constance in the length of b. switch len(b) { @@ -56,11 +71,12 @@ func slide(b []byte) uint64 { h *= prime3 h ^= h >> 32 return h -`, sumSlideSize, sumSlideSize) +`) for i := 1; i <= sumSlideSize; i++ { fmt.Fprintf(w, ` case %d: + b_%d = (*[%d]byte)(b) goto sz_%d -`, i, i) +`, i, i, i, i) } w.WriteString(` default: panic("unreachable; slide overflow") @@ -74,13 +90,13 @@ func slide(b []byte) uint64 { i := sumSlideSize - k for ; i >= 32; i -= 32 { fmt.Fprintf(w, `sz_%d: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_%d[0:8])) + v2 = round(v2, u64(b_%d[8:16])) + v3 = round(v3, u64(b_%d[16:24])) + v4 = round(v4, u64(b_%d[24:32])) + b_%d = (*[%d]byte)(b_%d[32:]) -`, i) +`, i, i, i, i, i, i-32, i-32, i) // POTENTIAL OPTIMIZATION: b[32:] creates an addition to bump the pointer which means the address dependency on the memory loads is not resolved before the jmp table. I know two fixes: // - change b to a pointer to the end of the slice and subtract the total offset. I don't know how to do this in pure go. // - don't bother reusing the slides, this means each load instruction can hardcode the offset. Make the code significantly bigger and i-cache worst, altho I didn't tried it. @@ -106,11 +122,11 @@ func slide(b []byte) uint64 { i := 31 - k for ; i >= 8; i -= 8 { fmt.Fprintf(w, `sz_%dl: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_%d[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_%d = (*[%d]byte)(b_%d[8:]) -`, i) +`, i, i, i-8, i-8, i) } fmt.Fprintf(w, `goto sz_%dl @@ -121,28 +137,30 @@ func slide(b []byte) uint64 { for k := range 4 { i := 7 - k fmt.Fprintf(w, `sz_%dl: - h ^= uint64(u32(b[:4])) * prime1 + h ^= uint64(u32(b_%d[:4])) * prime1 h = rol23(h)*prime2 + prime3 - b = b[4:] + b_%d = (*[%d]byte)(b_%d[4:]) goto sz_%dl -`, i, i-4) +`, i, i, i-4, i-4, i, i-4) } w.WriteString(" // This is the 1 bytes trailing slide.\n") for i := 4; i > 1; { i-- fmt.Fprintf(w, `sz_%dl: - h ^= uint64(b[0]) * prime5 + h ^= uint64(b_%d[0]) * prime5 h = rol11(h) * prime1 - b = b[1:] + b_%d = (*[%d]byte)(b_%d[1:]) -`, i) +`, i, i, i-1, i-1, i) } // Carefull here, the loop above fallthrough to zero. w.WriteString(` // Finally the terminator. sz_0l: + _ = b_0 // this avoids a bunch of if i != 0 { in codegen and is optimized away. + h ^= h >> 33 h *= prime2 h ^= h >> 29 diff --git a/xxhash_asm_amd64.go b/xxhash_asm_amd64.go index 531fa56..b04a614 100644 --- a/xxhash_asm_amd64.go +++ b/xxhash_asm_amd64.go @@ -24,11 +24,14 @@ var useAvx512 = cpuid.CPU.Supports( // Sum64 computes the 64-bit xxHash digest of b with a zero seed. func Sum64(b []byte) uint64 { - if len(b) <= slideLength { - return slide(b) - } - if useAvx512 { - return sum64Avx512(b) + if slideLength != 0 { + // If we don't have the slide sum small blocks are much slower. + if len(b) <= slideLength { + return slide(b) + } + if useAvx512 { + return sum64Avx512(b) + } } return sum64Scalar(b) } diff --git a/xxhash_not_slide.go b/xxhash_not_slide.go new file mode 100644 index 0000000..9a75e94 --- /dev/null +++ b/xxhash_not_slide.go @@ -0,0 +1,10 @@ +//go:build !go1.17 +// +build !go1.17 + +package xxhash + +const slideLength = 0 + +func slide(b []byte) uint64 { + panic("unreachable") +} diff --git a/xxhash_slide.go b/xxhash_slide.go index 23cf29a..f8b53cb 100644 --- a/xxhash_slide.go +++ b/xxhash_slide.go @@ -1,3 +1,6 @@ +//go:build go1.17 +// +build go1.17 + package xxhash // Generated by gen/slide.go. DO NOT EDIT. @@ -19,8 +22,10 @@ func slide(b []byte) uint64 { // It probably generate unnecessary MOVs but the critical path includes LAT3 multiplies for each block, so there is plenty of time to dispatch renames. // - The compiler is basic block based and will do a good enough job at layout. This is true for some the go compiler, llvm and some of gcc. // This means I make very liberal use of goto, they shouldn't be red as JMPs but abstract basic blocks links. + // - The compiler has some SSA passes. + // This is used for all the b_* tricks. - // Setups variables here since go doesn't want use to do dangerous gotos. + // Setup variables here since go doesn't want use to do dangerous gotos. v1 := prime1 v1 += prime2 v2 := prime2 @@ -30,6 +35,139 @@ func slide(b []byte) uint64 { h := prime5 n := uint64(len(b)) + // The go compiler has multiple oversight in the propragation of proofs through Phi nodes. Using array pointers is a very unsubtle hint and compiles to nothing. + // Because we assume the compiler has some low level SSA passes this is otherwise free. + var ( + b_0 *[0]byte + b_1 *[1]byte + b_2 *[2]byte + b_3 *[3]byte + b_4 *[4]byte + b_5 *[5]byte + b_6 *[6]byte + b_7 *[7]byte + b_8 *[8]byte + b_9 *[9]byte + b_10 *[10]byte + b_11 *[11]byte + b_12 *[12]byte + b_13 *[13]byte + b_14 *[14]byte + b_15 *[15]byte + b_16 *[16]byte + b_17 *[17]byte + b_18 *[18]byte + b_19 *[19]byte + b_20 *[20]byte + b_21 *[21]byte + b_22 *[22]byte + b_23 *[23]byte + b_24 *[24]byte + b_25 *[25]byte + b_26 *[26]byte + b_27 *[27]byte + b_28 *[28]byte + b_29 *[29]byte + b_30 *[30]byte + b_31 *[31]byte + b_32 *[32]byte + b_33 *[33]byte + b_34 *[34]byte + b_35 *[35]byte + b_36 *[36]byte + b_37 *[37]byte + b_38 *[38]byte + b_39 *[39]byte + b_40 *[40]byte + b_41 *[41]byte + b_42 *[42]byte + b_43 *[43]byte + b_44 *[44]byte + b_45 *[45]byte + b_46 *[46]byte + b_47 *[47]byte + b_48 *[48]byte + b_49 *[49]byte + b_50 *[50]byte + b_51 *[51]byte + b_52 *[52]byte + b_53 *[53]byte + b_54 *[54]byte + b_55 *[55]byte + b_56 *[56]byte + b_57 *[57]byte + b_58 *[58]byte + b_59 *[59]byte + b_60 *[60]byte + b_61 *[61]byte + b_62 *[62]byte + b_63 *[63]byte + b_64 *[64]byte + b_65 *[65]byte + b_66 *[66]byte + b_67 *[67]byte + b_68 *[68]byte + b_69 *[69]byte + b_70 *[70]byte + b_71 *[71]byte + b_72 *[72]byte + b_73 *[73]byte + b_74 *[74]byte + b_75 *[75]byte + b_76 *[76]byte + b_77 *[77]byte + b_78 *[78]byte + b_79 *[79]byte + b_80 *[80]byte + b_81 *[81]byte + b_82 *[82]byte + b_83 *[83]byte + b_84 *[84]byte + b_85 *[85]byte + b_86 *[86]byte + b_87 *[87]byte + b_88 *[88]byte + b_89 *[89]byte + b_90 *[90]byte + b_91 *[91]byte + b_92 *[92]byte + b_93 *[93]byte + b_94 *[94]byte + b_95 *[95]byte + b_96 *[96]byte + b_97 *[97]byte + b_98 *[98]byte + b_99 *[99]byte + b_100 *[100]byte + b_101 *[101]byte + b_102 *[102]byte + b_103 *[103]byte + b_104 *[104]byte + b_105 *[105]byte + b_106 *[106]byte + b_107 *[107]byte + b_108 *[108]byte + b_109 *[109]byte + b_110 *[110]byte + b_111 *[111]byte + b_112 *[112]byte + b_113 *[113]byte + b_114 *[114]byte + b_115 *[115]byte + b_116 *[116]byte + b_117 *[117]byte + b_118 *[118]byte + b_119 *[119]byte + b_120 *[120]byte + b_121 *[121]byte + b_122 *[122]byte + b_123 *[123]byte + b_124 *[124]byte + b_125 *[125]byte + b_126 *[126]byte + b_127 *[127]byte + ) + // Jump table to various positions in the slide, this setups proofs for bounds checks. // From then on it need to make sure to maintain constance in the length of b. switch len(b) { @@ -43,258 +181,385 @@ func slide(b []byte) uint64 { h ^= h >> 32 return h case 1: + b_1 = (*[1]byte)(b) goto sz_1 case 2: + b_2 = (*[2]byte)(b) goto sz_2 case 3: + b_3 = (*[3]byte)(b) goto sz_3 case 4: + b_4 = (*[4]byte)(b) goto sz_4 case 5: + b_5 = (*[5]byte)(b) goto sz_5 case 6: + b_6 = (*[6]byte)(b) goto sz_6 case 7: + b_7 = (*[7]byte)(b) goto sz_7 case 8: + b_8 = (*[8]byte)(b) goto sz_8 case 9: + b_9 = (*[9]byte)(b) goto sz_9 case 10: + b_10 = (*[10]byte)(b) goto sz_10 case 11: + b_11 = (*[11]byte)(b) goto sz_11 case 12: + b_12 = (*[12]byte)(b) goto sz_12 case 13: + b_13 = (*[13]byte)(b) goto sz_13 case 14: + b_14 = (*[14]byte)(b) goto sz_14 case 15: + b_15 = (*[15]byte)(b) goto sz_15 case 16: + b_16 = (*[16]byte)(b) goto sz_16 case 17: + b_17 = (*[17]byte)(b) goto sz_17 case 18: + b_18 = (*[18]byte)(b) goto sz_18 case 19: + b_19 = (*[19]byte)(b) goto sz_19 case 20: + b_20 = (*[20]byte)(b) goto sz_20 case 21: + b_21 = (*[21]byte)(b) goto sz_21 case 22: + b_22 = (*[22]byte)(b) goto sz_22 case 23: + b_23 = (*[23]byte)(b) goto sz_23 case 24: + b_24 = (*[24]byte)(b) goto sz_24 case 25: + b_25 = (*[25]byte)(b) goto sz_25 case 26: + b_26 = (*[26]byte)(b) goto sz_26 case 27: + b_27 = (*[27]byte)(b) goto sz_27 case 28: + b_28 = (*[28]byte)(b) goto sz_28 case 29: + b_29 = (*[29]byte)(b) goto sz_29 case 30: + b_30 = (*[30]byte)(b) goto sz_30 case 31: + b_31 = (*[31]byte)(b) goto sz_31 case 32: + b_32 = (*[32]byte)(b) goto sz_32 case 33: + b_33 = (*[33]byte)(b) goto sz_33 case 34: + b_34 = (*[34]byte)(b) goto sz_34 case 35: + b_35 = (*[35]byte)(b) goto sz_35 case 36: + b_36 = (*[36]byte)(b) goto sz_36 case 37: + b_37 = (*[37]byte)(b) goto sz_37 case 38: + b_38 = (*[38]byte)(b) goto sz_38 case 39: + b_39 = (*[39]byte)(b) goto sz_39 case 40: + b_40 = (*[40]byte)(b) goto sz_40 case 41: + b_41 = (*[41]byte)(b) goto sz_41 case 42: + b_42 = (*[42]byte)(b) goto sz_42 case 43: + b_43 = (*[43]byte)(b) goto sz_43 case 44: + b_44 = (*[44]byte)(b) goto sz_44 case 45: + b_45 = (*[45]byte)(b) goto sz_45 case 46: + b_46 = (*[46]byte)(b) goto sz_46 case 47: + b_47 = (*[47]byte)(b) goto sz_47 case 48: + b_48 = (*[48]byte)(b) goto sz_48 case 49: + b_49 = (*[49]byte)(b) goto sz_49 case 50: + b_50 = (*[50]byte)(b) goto sz_50 case 51: + b_51 = (*[51]byte)(b) goto sz_51 case 52: + b_52 = (*[52]byte)(b) goto sz_52 case 53: + b_53 = (*[53]byte)(b) goto sz_53 case 54: + b_54 = (*[54]byte)(b) goto sz_54 case 55: + b_55 = (*[55]byte)(b) goto sz_55 case 56: + b_56 = (*[56]byte)(b) goto sz_56 case 57: + b_57 = (*[57]byte)(b) goto sz_57 case 58: + b_58 = (*[58]byte)(b) goto sz_58 case 59: + b_59 = (*[59]byte)(b) goto sz_59 case 60: + b_60 = (*[60]byte)(b) goto sz_60 case 61: + b_61 = (*[61]byte)(b) goto sz_61 case 62: + b_62 = (*[62]byte)(b) goto sz_62 case 63: + b_63 = (*[63]byte)(b) goto sz_63 case 64: + b_64 = (*[64]byte)(b) goto sz_64 case 65: + b_65 = (*[65]byte)(b) goto sz_65 case 66: + b_66 = (*[66]byte)(b) goto sz_66 case 67: + b_67 = (*[67]byte)(b) goto sz_67 case 68: + b_68 = (*[68]byte)(b) goto sz_68 case 69: + b_69 = (*[69]byte)(b) goto sz_69 case 70: + b_70 = (*[70]byte)(b) goto sz_70 case 71: + b_71 = (*[71]byte)(b) goto sz_71 case 72: + b_72 = (*[72]byte)(b) goto sz_72 case 73: + b_73 = (*[73]byte)(b) goto sz_73 case 74: + b_74 = (*[74]byte)(b) goto sz_74 case 75: + b_75 = (*[75]byte)(b) goto sz_75 case 76: + b_76 = (*[76]byte)(b) goto sz_76 case 77: + b_77 = (*[77]byte)(b) goto sz_77 case 78: + b_78 = (*[78]byte)(b) goto sz_78 case 79: + b_79 = (*[79]byte)(b) goto sz_79 case 80: + b_80 = (*[80]byte)(b) goto sz_80 case 81: + b_81 = (*[81]byte)(b) goto sz_81 case 82: + b_82 = (*[82]byte)(b) goto sz_82 case 83: + b_83 = (*[83]byte)(b) goto sz_83 case 84: + b_84 = (*[84]byte)(b) goto sz_84 case 85: + b_85 = (*[85]byte)(b) goto sz_85 case 86: + b_86 = (*[86]byte)(b) goto sz_86 case 87: + b_87 = (*[87]byte)(b) goto sz_87 case 88: + b_88 = (*[88]byte)(b) goto sz_88 case 89: + b_89 = (*[89]byte)(b) goto sz_89 case 90: + b_90 = (*[90]byte)(b) goto sz_90 case 91: + b_91 = (*[91]byte)(b) goto sz_91 case 92: + b_92 = (*[92]byte)(b) goto sz_92 case 93: + b_93 = (*[93]byte)(b) goto sz_93 case 94: + b_94 = (*[94]byte)(b) goto sz_94 case 95: + b_95 = (*[95]byte)(b) goto sz_95 case 96: + b_96 = (*[96]byte)(b) goto sz_96 case 97: + b_97 = (*[97]byte)(b) goto sz_97 case 98: + b_98 = (*[98]byte)(b) goto sz_98 case 99: + b_99 = (*[99]byte)(b) goto sz_99 case 100: + b_100 = (*[100]byte)(b) goto sz_100 case 101: + b_101 = (*[101]byte)(b) goto sz_101 case 102: + b_102 = (*[102]byte)(b) goto sz_102 case 103: + b_103 = (*[103]byte)(b) goto sz_103 case 104: + b_104 = (*[104]byte)(b) goto sz_104 case 105: + b_105 = (*[105]byte)(b) goto sz_105 case 106: + b_106 = (*[106]byte)(b) goto sz_106 case 107: + b_107 = (*[107]byte)(b) goto sz_107 case 108: + b_108 = (*[108]byte)(b) goto sz_108 case 109: + b_109 = (*[109]byte)(b) goto sz_109 case 110: + b_110 = (*[110]byte)(b) goto sz_110 case 111: + b_111 = (*[111]byte)(b) goto sz_111 case 112: + b_112 = (*[112]byte)(b) goto sz_112 case 113: + b_113 = (*[113]byte)(b) goto sz_113 case 114: + b_114 = (*[114]byte)(b) goto sz_114 case 115: + b_115 = (*[115]byte)(b) goto sz_115 case 116: + b_116 = (*[116]byte)(b) goto sz_116 case 117: + b_117 = (*[117]byte)(b) goto sz_117 case 118: + b_118 = (*[118]byte)(b) goto sz_118 case 119: + b_119 = (*[119]byte)(b) goto sz_119 case 120: + b_120 = (*[120]byte)(b) goto sz_120 case 121: + b_121 = (*[121]byte)(b) goto sz_121 case 122: + b_122 = (*[122]byte)(b) goto sz_122 case 123: + b_123 = (*[123]byte)(b) goto sz_123 case 124: + b_124 = (*[124]byte)(b) goto sz_124 case 125: + b_125 = (*[125]byte)(b) goto sz_125 case 126: + b_126 = (*[126]byte)(b) goto sz_126 case 127: + b_127 = (*[127]byte)(b) goto sz_127 default: panic("unreachable; slide overflow") @@ -302,25 +567,25 @@ func slide(b []byte) uint64 { // Theses are the main slides, they handle 32 bytes 4 × 8 bytes at a time using ILP. sz_127: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_127[0:8])) + v2 = round(v2, u64(b_127[8:16])) + v3 = round(v3, u64(b_127[16:24])) + v4 = round(v4, u64(b_127[24:32])) + b_95 = (*[95]byte)(b_127[32:]) sz_95: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_95[0:8])) + v2 = round(v2, u64(b_95[8:16])) + v3 = round(v3, u64(b_95[16:24])) + v4 = round(v4, u64(b_95[24:32])) + b_63 = (*[63]byte)(b_95[32:]) sz_63: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_63[0:8])) + v2 = round(v2, u64(b_63[8:16])) + v3 = round(v3, u64(b_63[16:24])) + v4 = round(v4, u64(b_63[24:32])) + b_31 = (*[31]byte)(b_63[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -333,25 +598,25 @@ sz_31: goto sz_31l sz_126: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_126[0:8])) + v2 = round(v2, u64(b_126[8:16])) + v3 = round(v3, u64(b_126[16:24])) + v4 = round(v4, u64(b_126[24:32])) + b_94 = (*[94]byte)(b_126[32:]) sz_94: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_94[0:8])) + v2 = round(v2, u64(b_94[8:16])) + v3 = round(v3, u64(b_94[16:24])) + v4 = round(v4, u64(b_94[24:32])) + b_62 = (*[62]byte)(b_94[32:]) sz_62: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_62[0:8])) + v2 = round(v2, u64(b_62[8:16])) + v3 = round(v3, u64(b_62[16:24])) + v4 = round(v4, u64(b_62[24:32])) + b_30 = (*[30]byte)(b_62[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -364,25 +629,25 @@ sz_30: goto sz_30l sz_125: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_125[0:8])) + v2 = round(v2, u64(b_125[8:16])) + v3 = round(v3, u64(b_125[16:24])) + v4 = round(v4, u64(b_125[24:32])) + b_93 = (*[93]byte)(b_125[32:]) sz_93: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_93[0:8])) + v2 = round(v2, u64(b_93[8:16])) + v3 = round(v3, u64(b_93[16:24])) + v4 = round(v4, u64(b_93[24:32])) + b_61 = (*[61]byte)(b_93[32:]) sz_61: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_61[0:8])) + v2 = round(v2, u64(b_61[8:16])) + v3 = round(v3, u64(b_61[16:24])) + v4 = round(v4, u64(b_61[24:32])) + b_29 = (*[29]byte)(b_61[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -395,25 +660,25 @@ sz_29: goto sz_29l sz_124: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_124[0:8])) + v2 = round(v2, u64(b_124[8:16])) + v3 = round(v3, u64(b_124[16:24])) + v4 = round(v4, u64(b_124[24:32])) + b_92 = (*[92]byte)(b_124[32:]) sz_92: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_92[0:8])) + v2 = round(v2, u64(b_92[8:16])) + v3 = round(v3, u64(b_92[16:24])) + v4 = round(v4, u64(b_92[24:32])) + b_60 = (*[60]byte)(b_92[32:]) sz_60: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_60[0:8])) + v2 = round(v2, u64(b_60[8:16])) + v3 = round(v3, u64(b_60[16:24])) + v4 = round(v4, u64(b_60[24:32])) + b_28 = (*[28]byte)(b_60[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -426,25 +691,25 @@ sz_28: goto sz_28l sz_123: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_123[0:8])) + v2 = round(v2, u64(b_123[8:16])) + v3 = round(v3, u64(b_123[16:24])) + v4 = round(v4, u64(b_123[24:32])) + b_91 = (*[91]byte)(b_123[32:]) sz_91: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_91[0:8])) + v2 = round(v2, u64(b_91[8:16])) + v3 = round(v3, u64(b_91[16:24])) + v4 = round(v4, u64(b_91[24:32])) + b_59 = (*[59]byte)(b_91[32:]) sz_59: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_59[0:8])) + v2 = round(v2, u64(b_59[8:16])) + v3 = round(v3, u64(b_59[16:24])) + v4 = round(v4, u64(b_59[24:32])) + b_27 = (*[27]byte)(b_59[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -457,25 +722,25 @@ sz_27: goto sz_27l sz_122: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_122[0:8])) + v2 = round(v2, u64(b_122[8:16])) + v3 = round(v3, u64(b_122[16:24])) + v4 = round(v4, u64(b_122[24:32])) + b_90 = (*[90]byte)(b_122[32:]) sz_90: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_90[0:8])) + v2 = round(v2, u64(b_90[8:16])) + v3 = round(v3, u64(b_90[16:24])) + v4 = round(v4, u64(b_90[24:32])) + b_58 = (*[58]byte)(b_90[32:]) sz_58: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_58[0:8])) + v2 = round(v2, u64(b_58[8:16])) + v3 = round(v3, u64(b_58[16:24])) + v4 = round(v4, u64(b_58[24:32])) + b_26 = (*[26]byte)(b_58[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -488,25 +753,25 @@ sz_26: goto sz_26l sz_121: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_121[0:8])) + v2 = round(v2, u64(b_121[8:16])) + v3 = round(v3, u64(b_121[16:24])) + v4 = round(v4, u64(b_121[24:32])) + b_89 = (*[89]byte)(b_121[32:]) sz_89: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_89[0:8])) + v2 = round(v2, u64(b_89[8:16])) + v3 = round(v3, u64(b_89[16:24])) + v4 = round(v4, u64(b_89[24:32])) + b_57 = (*[57]byte)(b_89[32:]) sz_57: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_57[0:8])) + v2 = round(v2, u64(b_57[8:16])) + v3 = round(v3, u64(b_57[16:24])) + v4 = round(v4, u64(b_57[24:32])) + b_25 = (*[25]byte)(b_57[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -519,25 +784,25 @@ sz_25: goto sz_25l sz_120: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_120[0:8])) + v2 = round(v2, u64(b_120[8:16])) + v3 = round(v3, u64(b_120[16:24])) + v4 = round(v4, u64(b_120[24:32])) + b_88 = (*[88]byte)(b_120[32:]) sz_88: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_88[0:8])) + v2 = round(v2, u64(b_88[8:16])) + v3 = round(v3, u64(b_88[16:24])) + v4 = round(v4, u64(b_88[24:32])) + b_56 = (*[56]byte)(b_88[32:]) sz_56: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_56[0:8])) + v2 = round(v2, u64(b_56[8:16])) + v3 = round(v3, u64(b_56[16:24])) + v4 = round(v4, u64(b_56[24:32])) + b_24 = (*[24]byte)(b_56[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -550,25 +815,25 @@ sz_24: goto sz_24l sz_119: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_119[0:8])) + v2 = round(v2, u64(b_119[8:16])) + v3 = round(v3, u64(b_119[16:24])) + v4 = round(v4, u64(b_119[24:32])) + b_87 = (*[87]byte)(b_119[32:]) sz_87: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_87[0:8])) + v2 = round(v2, u64(b_87[8:16])) + v3 = round(v3, u64(b_87[16:24])) + v4 = round(v4, u64(b_87[24:32])) + b_55 = (*[55]byte)(b_87[32:]) sz_55: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_55[0:8])) + v2 = round(v2, u64(b_55[8:16])) + v3 = round(v3, u64(b_55[16:24])) + v4 = round(v4, u64(b_55[24:32])) + b_23 = (*[23]byte)(b_55[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -581,25 +846,25 @@ sz_23: goto sz_23l sz_118: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_118[0:8])) + v2 = round(v2, u64(b_118[8:16])) + v3 = round(v3, u64(b_118[16:24])) + v4 = round(v4, u64(b_118[24:32])) + b_86 = (*[86]byte)(b_118[32:]) sz_86: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_86[0:8])) + v2 = round(v2, u64(b_86[8:16])) + v3 = round(v3, u64(b_86[16:24])) + v4 = round(v4, u64(b_86[24:32])) + b_54 = (*[54]byte)(b_86[32:]) sz_54: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_54[0:8])) + v2 = round(v2, u64(b_54[8:16])) + v3 = round(v3, u64(b_54[16:24])) + v4 = round(v4, u64(b_54[24:32])) + b_22 = (*[22]byte)(b_54[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -612,25 +877,25 @@ sz_22: goto sz_22l sz_117: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_117[0:8])) + v2 = round(v2, u64(b_117[8:16])) + v3 = round(v3, u64(b_117[16:24])) + v4 = round(v4, u64(b_117[24:32])) + b_85 = (*[85]byte)(b_117[32:]) sz_85: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_85[0:8])) + v2 = round(v2, u64(b_85[8:16])) + v3 = round(v3, u64(b_85[16:24])) + v4 = round(v4, u64(b_85[24:32])) + b_53 = (*[53]byte)(b_85[32:]) sz_53: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_53[0:8])) + v2 = round(v2, u64(b_53[8:16])) + v3 = round(v3, u64(b_53[16:24])) + v4 = round(v4, u64(b_53[24:32])) + b_21 = (*[21]byte)(b_53[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -643,25 +908,25 @@ sz_21: goto sz_21l sz_116: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_116[0:8])) + v2 = round(v2, u64(b_116[8:16])) + v3 = round(v3, u64(b_116[16:24])) + v4 = round(v4, u64(b_116[24:32])) + b_84 = (*[84]byte)(b_116[32:]) sz_84: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_84[0:8])) + v2 = round(v2, u64(b_84[8:16])) + v3 = round(v3, u64(b_84[16:24])) + v4 = round(v4, u64(b_84[24:32])) + b_52 = (*[52]byte)(b_84[32:]) sz_52: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_52[0:8])) + v2 = round(v2, u64(b_52[8:16])) + v3 = round(v3, u64(b_52[16:24])) + v4 = round(v4, u64(b_52[24:32])) + b_20 = (*[20]byte)(b_52[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -674,25 +939,25 @@ sz_20: goto sz_20l sz_115: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_115[0:8])) + v2 = round(v2, u64(b_115[8:16])) + v3 = round(v3, u64(b_115[16:24])) + v4 = round(v4, u64(b_115[24:32])) + b_83 = (*[83]byte)(b_115[32:]) sz_83: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_83[0:8])) + v2 = round(v2, u64(b_83[8:16])) + v3 = round(v3, u64(b_83[16:24])) + v4 = round(v4, u64(b_83[24:32])) + b_51 = (*[51]byte)(b_83[32:]) sz_51: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_51[0:8])) + v2 = round(v2, u64(b_51[8:16])) + v3 = round(v3, u64(b_51[16:24])) + v4 = round(v4, u64(b_51[24:32])) + b_19 = (*[19]byte)(b_51[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -705,25 +970,25 @@ sz_19: goto sz_19l sz_114: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_114[0:8])) + v2 = round(v2, u64(b_114[8:16])) + v3 = round(v3, u64(b_114[16:24])) + v4 = round(v4, u64(b_114[24:32])) + b_82 = (*[82]byte)(b_114[32:]) sz_82: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_82[0:8])) + v2 = round(v2, u64(b_82[8:16])) + v3 = round(v3, u64(b_82[16:24])) + v4 = round(v4, u64(b_82[24:32])) + b_50 = (*[50]byte)(b_82[32:]) sz_50: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_50[0:8])) + v2 = round(v2, u64(b_50[8:16])) + v3 = round(v3, u64(b_50[16:24])) + v4 = round(v4, u64(b_50[24:32])) + b_18 = (*[18]byte)(b_50[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -736,25 +1001,25 @@ sz_18: goto sz_18l sz_113: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_113[0:8])) + v2 = round(v2, u64(b_113[8:16])) + v3 = round(v3, u64(b_113[16:24])) + v4 = round(v4, u64(b_113[24:32])) + b_81 = (*[81]byte)(b_113[32:]) sz_81: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_81[0:8])) + v2 = round(v2, u64(b_81[8:16])) + v3 = round(v3, u64(b_81[16:24])) + v4 = round(v4, u64(b_81[24:32])) + b_49 = (*[49]byte)(b_81[32:]) sz_49: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_49[0:8])) + v2 = round(v2, u64(b_49[8:16])) + v3 = round(v3, u64(b_49[16:24])) + v4 = round(v4, u64(b_49[24:32])) + b_17 = (*[17]byte)(b_49[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -767,25 +1032,25 @@ sz_17: goto sz_17l sz_112: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_112[0:8])) + v2 = round(v2, u64(b_112[8:16])) + v3 = round(v3, u64(b_112[16:24])) + v4 = round(v4, u64(b_112[24:32])) + b_80 = (*[80]byte)(b_112[32:]) sz_80: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_80[0:8])) + v2 = round(v2, u64(b_80[8:16])) + v3 = round(v3, u64(b_80[16:24])) + v4 = round(v4, u64(b_80[24:32])) + b_48 = (*[48]byte)(b_80[32:]) sz_48: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_48[0:8])) + v2 = round(v2, u64(b_48[8:16])) + v3 = round(v3, u64(b_48[16:24])) + v4 = round(v4, u64(b_48[24:32])) + b_16 = (*[16]byte)(b_48[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -798,25 +1063,25 @@ sz_16: goto sz_16l sz_111: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_111[0:8])) + v2 = round(v2, u64(b_111[8:16])) + v3 = round(v3, u64(b_111[16:24])) + v4 = round(v4, u64(b_111[24:32])) + b_79 = (*[79]byte)(b_111[32:]) sz_79: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_79[0:8])) + v2 = round(v2, u64(b_79[8:16])) + v3 = round(v3, u64(b_79[16:24])) + v4 = round(v4, u64(b_79[24:32])) + b_47 = (*[47]byte)(b_79[32:]) sz_47: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_47[0:8])) + v2 = round(v2, u64(b_47[8:16])) + v3 = round(v3, u64(b_47[16:24])) + v4 = round(v4, u64(b_47[24:32])) + b_15 = (*[15]byte)(b_47[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -829,25 +1094,25 @@ sz_15: goto sz_15l sz_110: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_110[0:8])) + v2 = round(v2, u64(b_110[8:16])) + v3 = round(v3, u64(b_110[16:24])) + v4 = round(v4, u64(b_110[24:32])) + b_78 = (*[78]byte)(b_110[32:]) sz_78: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_78[0:8])) + v2 = round(v2, u64(b_78[8:16])) + v3 = round(v3, u64(b_78[16:24])) + v4 = round(v4, u64(b_78[24:32])) + b_46 = (*[46]byte)(b_78[32:]) sz_46: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_46[0:8])) + v2 = round(v2, u64(b_46[8:16])) + v3 = round(v3, u64(b_46[16:24])) + v4 = round(v4, u64(b_46[24:32])) + b_14 = (*[14]byte)(b_46[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -860,25 +1125,25 @@ sz_14: goto sz_14l sz_109: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_109[0:8])) + v2 = round(v2, u64(b_109[8:16])) + v3 = round(v3, u64(b_109[16:24])) + v4 = round(v4, u64(b_109[24:32])) + b_77 = (*[77]byte)(b_109[32:]) sz_77: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_77[0:8])) + v2 = round(v2, u64(b_77[8:16])) + v3 = round(v3, u64(b_77[16:24])) + v4 = round(v4, u64(b_77[24:32])) + b_45 = (*[45]byte)(b_77[32:]) sz_45: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_45[0:8])) + v2 = round(v2, u64(b_45[8:16])) + v3 = round(v3, u64(b_45[16:24])) + v4 = round(v4, u64(b_45[24:32])) + b_13 = (*[13]byte)(b_45[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -891,25 +1156,25 @@ sz_13: goto sz_13l sz_108: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_108[0:8])) + v2 = round(v2, u64(b_108[8:16])) + v3 = round(v3, u64(b_108[16:24])) + v4 = round(v4, u64(b_108[24:32])) + b_76 = (*[76]byte)(b_108[32:]) sz_76: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_76[0:8])) + v2 = round(v2, u64(b_76[8:16])) + v3 = round(v3, u64(b_76[16:24])) + v4 = round(v4, u64(b_76[24:32])) + b_44 = (*[44]byte)(b_76[32:]) sz_44: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_44[0:8])) + v2 = round(v2, u64(b_44[8:16])) + v3 = round(v3, u64(b_44[16:24])) + v4 = round(v4, u64(b_44[24:32])) + b_12 = (*[12]byte)(b_44[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -922,25 +1187,25 @@ sz_12: goto sz_12l sz_107: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_107[0:8])) + v2 = round(v2, u64(b_107[8:16])) + v3 = round(v3, u64(b_107[16:24])) + v4 = round(v4, u64(b_107[24:32])) + b_75 = (*[75]byte)(b_107[32:]) sz_75: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_75[0:8])) + v2 = round(v2, u64(b_75[8:16])) + v3 = round(v3, u64(b_75[16:24])) + v4 = round(v4, u64(b_75[24:32])) + b_43 = (*[43]byte)(b_75[32:]) sz_43: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_43[0:8])) + v2 = round(v2, u64(b_43[8:16])) + v3 = round(v3, u64(b_43[16:24])) + v4 = round(v4, u64(b_43[24:32])) + b_11 = (*[11]byte)(b_43[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -953,25 +1218,25 @@ sz_11: goto sz_11l sz_106: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_106[0:8])) + v2 = round(v2, u64(b_106[8:16])) + v3 = round(v3, u64(b_106[16:24])) + v4 = round(v4, u64(b_106[24:32])) + b_74 = (*[74]byte)(b_106[32:]) sz_74: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_74[0:8])) + v2 = round(v2, u64(b_74[8:16])) + v3 = round(v3, u64(b_74[16:24])) + v4 = round(v4, u64(b_74[24:32])) + b_42 = (*[42]byte)(b_74[32:]) sz_42: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_42[0:8])) + v2 = round(v2, u64(b_42[8:16])) + v3 = round(v3, u64(b_42[16:24])) + v4 = round(v4, u64(b_42[24:32])) + b_10 = (*[10]byte)(b_42[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -984,25 +1249,25 @@ sz_10: goto sz_10l sz_105: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_105[0:8])) + v2 = round(v2, u64(b_105[8:16])) + v3 = round(v3, u64(b_105[16:24])) + v4 = round(v4, u64(b_105[24:32])) + b_73 = (*[73]byte)(b_105[32:]) sz_73: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_73[0:8])) + v2 = round(v2, u64(b_73[8:16])) + v3 = round(v3, u64(b_73[16:24])) + v4 = round(v4, u64(b_73[24:32])) + b_41 = (*[41]byte)(b_73[32:]) sz_41: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_41[0:8])) + v2 = round(v2, u64(b_41[8:16])) + v3 = round(v3, u64(b_41[16:24])) + v4 = round(v4, u64(b_41[24:32])) + b_9 = (*[9]byte)(b_41[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1015,25 +1280,25 @@ sz_9: goto sz_9l sz_104: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_104[0:8])) + v2 = round(v2, u64(b_104[8:16])) + v3 = round(v3, u64(b_104[16:24])) + v4 = round(v4, u64(b_104[24:32])) + b_72 = (*[72]byte)(b_104[32:]) sz_72: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_72[0:8])) + v2 = round(v2, u64(b_72[8:16])) + v3 = round(v3, u64(b_72[16:24])) + v4 = round(v4, u64(b_72[24:32])) + b_40 = (*[40]byte)(b_72[32:]) sz_40: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_40[0:8])) + v2 = round(v2, u64(b_40[8:16])) + v3 = round(v3, u64(b_40[16:24])) + v4 = round(v4, u64(b_40[24:32])) + b_8 = (*[8]byte)(b_40[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1046,25 +1311,25 @@ sz_8: goto sz_8l sz_103: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_103[0:8])) + v2 = round(v2, u64(b_103[8:16])) + v3 = round(v3, u64(b_103[16:24])) + v4 = round(v4, u64(b_103[24:32])) + b_71 = (*[71]byte)(b_103[32:]) sz_71: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_71[0:8])) + v2 = round(v2, u64(b_71[8:16])) + v3 = round(v3, u64(b_71[16:24])) + v4 = round(v4, u64(b_71[24:32])) + b_39 = (*[39]byte)(b_71[32:]) sz_39: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_39[0:8])) + v2 = round(v2, u64(b_39[8:16])) + v3 = round(v3, u64(b_39[16:24])) + v4 = round(v4, u64(b_39[24:32])) + b_7 = (*[7]byte)(b_39[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1077,25 +1342,25 @@ sz_7: goto sz_7l sz_102: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_102[0:8])) + v2 = round(v2, u64(b_102[8:16])) + v3 = round(v3, u64(b_102[16:24])) + v4 = round(v4, u64(b_102[24:32])) + b_70 = (*[70]byte)(b_102[32:]) sz_70: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_70[0:8])) + v2 = round(v2, u64(b_70[8:16])) + v3 = round(v3, u64(b_70[16:24])) + v4 = round(v4, u64(b_70[24:32])) + b_38 = (*[38]byte)(b_70[32:]) sz_38: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_38[0:8])) + v2 = round(v2, u64(b_38[8:16])) + v3 = round(v3, u64(b_38[16:24])) + v4 = round(v4, u64(b_38[24:32])) + b_6 = (*[6]byte)(b_38[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1108,25 +1373,25 @@ sz_6: goto sz_6l sz_101: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_101[0:8])) + v2 = round(v2, u64(b_101[8:16])) + v3 = round(v3, u64(b_101[16:24])) + v4 = round(v4, u64(b_101[24:32])) + b_69 = (*[69]byte)(b_101[32:]) sz_69: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_69[0:8])) + v2 = round(v2, u64(b_69[8:16])) + v3 = round(v3, u64(b_69[16:24])) + v4 = round(v4, u64(b_69[24:32])) + b_37 = (*[37]byte)(b_69[32:]) sz_37: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_37[0:8])) + v2 = round(v2, u64(b_37[8:16])) + v3 = round(v3, u64(b_37[16:24])) + v4 = round(v4, u64(b_37[24:32])) + b_5 = (*[5]byte)(b_37[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1139,25 +1404,25 @@ sz_5: goto sz_5l sz_100: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_100[0:8])) + v2 = round(v2, u64(b_100[8:16])) + v3 = round(v3, u64(b_100[16:24])) + v4 = round(v4, u64(b_100[24:32])) + b_68 = (*[68]byte)(b_100[32:]) sz_68: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_68[0:8])) + v2 = round(v2, u64(b_68[8:16])) + v3 = round(v3, u64(b_68[16:24])) + v4 = round(v4, u64(b_68[24:32])) + b_36 = (*[36]byte)(b_68[32:]) sz_36: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_36[0:8])) + v2 = round(v2, u64(b_36[8:16])) + v3 = round(v3, u64(b_36[16:24])) + v4 = round(v4, u64(b_36[24:32])) + b_4 = (*[4]byte)(b_36[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1170,25 +1435,25 @@ sz_4: goto sz_4l sz_99: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_99[0:8])) + v2 = round(v2, u64(b_99[8:16])) + v3 = round(v3, u64(b_99[16:24])) + v4 = round(v4, u64(b_99[24:32])) + b_67 = (*[67]byte)(b_99[32:]) sz_67: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_67[0:8])) + v2 = round(v2, u64(b_67[8:16])) + v3 = round(v3, u64(b_67[16:24])) + v4 = round(v4, u64(b_67[24:32])) + b_35 = (*[35]byte)(b_67[32:]) sz_35: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_35[0:8])) + v2 = round(v2, u64(b_35[8:16])) + v3 = round(v3, u64(b_35[16:24])) + v4 = round(v4, u64(b_35[24:32])) + b_3 = (*[3]byte)(b_35[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1201,25 +1466,25 @@ sz_3: goto sz_3l sz_98: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_98[0:8])) + v2 = round(v2, u64(b_98[8:16])) + v3 = round(v3, u64(b_98[16:24])) + v4 = round(v4, u64(b_98[24:32])) + b_66 = (*[66]byte)(b_98[32:]) sz_66: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_66[0:8])) + v2 = round(v2, u64(b_66[8:16])) + v3 = round(v3, u64(b_66[16:24])) + v4 = round(v4, u64(b_66[24:32])) + b_34 = (*[34]byte)(b_66[32:]) sz_34: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_34[0:8])) + v2 = round(v2, u64(b_34[8:16])) + v3 = round(v3, u64(b_34[16:24])) + v4 = round(v4, u64(b_34[24:32])) + b_2 = (*[2]byte)(b_34[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1232,25 +1497,25 @@ sz_2: goto sz_2l sz_97: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_97[0:8])) + v2 = round(v2, u64(b_97[8:16])) + v3 = round(v3, u64(b_97[16:24])) + v4 = round(v4, u64(b_97[24:32])) + b_65 = (*[65]byte)(b_97[32:]) sz_65: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_65[0:8])) + v2 = round(v2, u64(b_65[8:16])) + v3 = round(v3, u64(b_65[16:24])) + v4 = round(v4, u64(b_65[24:32])) + b_33 = (*[33]byte)(b_65[32:]) sz_33: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_33[0:8])) + v2 = round(v2, u64(b_33[8:16])) + v3 = round(v3, u64(b_33[16:24])) + v4 = round(v4, u64(b_33[24:32])) + b_1 = (*[1]byte)(b_33[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1263,25 +1528,25 @@ sz_1: goto sz_1l sz_96: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_96[0:8])) + v2 = round(v2, u64(b_96[8:16])) + v3 = round(v3, u64(b_96[16:24])) + v4 = round(v4, u64(b_96[24:32])) + b_64 = (*[64]byte)(b_96[32:]) sz_64: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_64[0:8])) + v2 = round(v2, u64(b_64[8:16])) + v3 = round(v3, u64(b_64[16:24])) + v4 = round(v4, u64(b_64[24:32])) + b_32 = (*[32]byte)(b_64[32:]) sz_32: - v1 = round(v1, u64(b[0:8])) - v2 = round(v2, u64(b[8:16])) - v3 = round(v3, u64(b[16:24])) - v4 = round(v4, u64(b[24:32])) - b = b[32:] + v1 = round(v1, u64(b_32[0:8])) + v2 = round(v2, u64(b_32[8:16])) + v3 = round(v3, u64(b_32[16:24])) + v4 = round(v4, u64(b_32[24:32])) + b_0 = (*[0]byte)(b_32[32:]) h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1294,184 +1559,186 @@ sz_32: // Theses are 8 bytes block trailing slides. sz_31l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_31[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_23 = (*[23]byte)(b_31[8:]) sz_23l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_23[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_15 = (*[15]byte)(b_23[8:]) sz_15l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_15[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_7 = (*[7]byte)(b_15[8:]) goto sz_7l sz_30l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_30[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_22 = (*[22]byte)(b_30[8:]) sz_22l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_22[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_14 = (*[14]byte)(b_22[8:]) sz_14l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_14[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_6 = (*[6]byte)(b_14[8:]) goto sz_6l sz_29l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_29[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_21 = (*[21]byte)(b_29[8:]) sz_21l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_21[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_13 = (*[13]byte)(b_21[8:]) sz_13l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_13[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_5 = (*[5]byte)(b_13[8:]) goto sz_5l sz_28l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_28[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_20 = (*[20]byte)(b_28[8:]) sz_20l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_20[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_12 = (*[12]byte)(b_20[8:]) sz_12l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_12[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_4 = (*[4]byte)(b_12[8:]) goto sz_4l sz_27l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_27[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_19 = (*[19]byte)(b_27[8:]) sz_19l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_19[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_11 = (*[11]byte)(b_19[8:]) sz_11l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_11[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_3 = (*[3]byte)(b_11[8:]) goto sz_3l sz_26l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_26[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_18 = (*[18]byte)(b_26[8:]) sz_18l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_18[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_10 = (*[10]byte)(b_18[8:]) sz_10l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_10[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_2 = (*[2]byte)(b_10[8:]) goto sz_2l sz_25l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_25[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_17 = (*[17]byte)(b_25[8:]) sz_17l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_17[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_9 = (*[9]byte)(b_17[8:]) sz_9l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_9[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_1 = (*[1]byte)(b_9[8:]) goto sz_1l sz_24l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_24[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_16 = (*[16]byte)(b_24[8:]) sz_16l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_16[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_8 = (*[8]byte)(b_16[8:]) sz_8l: - h ^= round(0, u64(b[0:8])) + h ^= round(0, u64(b_8[:8])) h = rol27(h)*prime1 + prime4 - b = b[8:] + b_0 = (*[0]byte)(b_8[8:]) goto sz_0l // Theses are the 4 bytes trailing slides. sz_7l: - h ^= uint64(u32(b[:4])) * prime1 + h ^= uint64(u32(b_7[:4])) * prime1 h = rol23(h)*prime2 + prime3 - b = b[4:] + b_3 = (*[3]byte)(b_7[4:]) goto sz_3l sz_6l: - h ^= uint64(u32(b[:4])) * prime1 + h ^= uint64(u32(b_6[:4])) * prime1 h = rol23(h)*prime2 + prime3 - b = b[4:] + b_2 = (*[2]byte)(b_6[4:]) goto sz_2l sz_5l: - h ^= uint64(u32(b[:4])) * prime1 + h ^= uint64(u32(b_5[:4])) * prime1 h = rol23(h)*prime2 + prime3 - b = b[4:] + b_1 = (*[1]byte)(b_5[4:]) goto sz_1l sz_4l: - h ^= uint64(u32(b[:4])) * prime1 + h ^= uint64(u32(b_4[:4])) * prime1 h = rol23(h)*prime2 + prime3 - b = b[4:] + b_0 = (*[0]byte)(b_4[4:]) goto sz_0l // This is the 1 bytes trailing slide. sz_3l: - h ^= uint64(b[0]) * prime5 + h ^= uint64(b_3[0]) * prime5 h = rol11(h) * prime1 - b = b[1:] + b_2 = (*[2]byte)(b_3[1:]) sz_2l: - h ^= uint64(b[0]) * prime5 + h ^= uint64(b_2[0]) * prime5 h = rol11(h) * prime1 - b = b[1:] + b_1 = (*[1]byte)(b_2[1:]) sz_1l: - h ^= uint64(b[0]) * prime5 + h ^= uint64(b_1[0]) * prime5 h = rol11(h) * prime1 - b = b[1:] + b_0 = (*[0]byte)(b_1[1:]) // Finally the terminator. sz_0l: + _ = b_0 // this avoids a bunch of if i != 0 { in codegen and is optimized away. + h ^= h >> 33 h *= prime2 h ^= h >> 29 From 084a7639852a05a4837c4be65c811426ec058de0 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Thu, 20 Jun 2024 08:28:17 +0200 Subject: [PATCH 11/16] manually inline u64 and u32 in the slide to work around go bug. See https://go.dev/issue/68081 golang/go#68081. --- gen/slide.go | 44 +- xxhash_slide.go | 2208 +++++++++++++++++++++++++++++++++++------------ 2 files changed, 1671 insertions(+), 581 deletions(-) diff --git a/gen/slide.go b/gen/slide.go index 47295c6..f0511dd 100644 --- a/gen/slide.go +++ b/gen/slide.go @@ -90,13 +90,23 @@ func slide(b []byte) uint64 { i := sumSlideSize - k for ; i >= 32; i -= 32 { fmt.Fprintf(w, `sz_%d: - v1 = round(v1, u64(b_%d[0:8])) - v2 = round(v2, u64(b_%d[8:16])) - v3 = round(v3, u64(b_%d[16:24])) - v4 = round(v4, u64(b_%d[24:32])) - b_%d = (*[%d]byte)(b_%d[32:]) + { + b := b_%d[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_%d = (*[%d]byte)(b_%d[32:]) + } -`, i, i, i, i, i, i-32, i-32, i) +`, i, i, i-32, i-32, i) // POTENTIAL OPTIMIZATION: b[32:] creates an addition to bump the pointer which means the address dependency on the memory loads is not resolved before the jmp table. I know two fixes: // - change b to a pointer to the end of the slice and subtract the total offset. I don't know how to do this in pure go. // - don't bother reusing the slides, this means each load instruction can hardcode the offset. Make the code significantly bigger and i-cache worst, altho I didn't tried it. @@ -122,9 +132,13 @@ func slide(b []byte) uint64 { i := 31 - k for ; i >= 8; i -= 8 { fmt.Fprintf(w, `sz_%dl: - h ^= round(0, u64(b_%d[:8])) - h = rol27(h)*prime1 + prime4 - b_%d = (*[%d]byte)(b_%d[8:]) + { + b := b_%d[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_%d = (*[%d]byte)(b_%d[8:]) + } `, i, i, i-8, i-8, i) } @@ -137,10 +151,14 @@ func slide(b []byte) uint64 { for k := range 4 { i := 7 - k fmt.Fprintf(w, `sz_%dl: - h ^= uint64(u32(b_%d[:4])) * prime1 - h = rol23(h)*prime2 + prime3 - b_%d = (*[%d]byte)(b_%d[4:]) - goto sz_%dl + { + b := b_%d[:] + load := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 // Work around for go.dev/issue/68081. + h ^= uint64(load) * prime1 + h = rol23(h)*prime2 + prime3 + b_%d = (*[%d]byte)(b_%d[4:]) + goto sz_%dl + } `, i, i, i-4, i-4, i, i-4) } diff --git a/xxhash_slide.go b/xxhash_slide.go index f8b53cb..bc265e8 100644 --- a/xxhash_slide.go +++ b/xxhash_slide.go @@ -567,25 +567,55 @@ func slide(b []byte) uint64 { // Theses are the main slides, they handle 32 bytes 4 × 8 bytes at a time using ILP. sz_127: - v1 = round(v1, u64(b_127[0:8])) - v2 = round(v2, u64(b_127[8:16])) - v3 = round(v3, u64(b_127[16:24])) - v4 = round(v4, u64(b_127[24:32])) - b_95 = (*[95]byte)(b_127[32:]) + { + b := b_127[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_95 = (*[95]byte)(b_127[32:]) + } sz_95: - v1 = round(v1, u64(b_95[0:8])) - v2 = round(v2, u64(b_95[8:16])) - v3 = round(v3, u64(b_95[16:24])) - v4 = round(v4, u64(b_95[24:32])) - b_63 = (*[63]byte)(b_95[32:]) + { + b := b_95[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_63 = (*[63]byte)(b_95[32:]) + } sz_63: - v1 = round(v1, u64(b_63[0:8])) - v2 = round(v2, u64(b_63[8:16])) - v3 = round(v3, u64(b_63[16:24])) - v4 = round(v4, u64(b_63[24:32])) - b_31 = (*[31]byte)(b_63[32:]) + { + b := b_63[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_31 = (*[31]byte)(b_63[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -598,25 +628,55 @@ sz_31: goto sz_31l sz_126: - v1 = round(v1, u64(b_126[0:8])) - v2 = round(v2, u64(b_126[8:16])) - v3 = round(v3, u64(b_126[16:24])) - v4 = round(v4, u64(b_126[24:32])) - b_94 = (*[94]byte)(b_126[32:]) + { + b := b_126[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_94 = (*[94]byte)(b_126[32:]) + } sz_94: - v1 = round(v1, u64(b_94[0:8])) - v2 = round(v2, u64(b_94[8:16])) - v3 = round(v3, u64(b_94[16:24])) - v4 = round(v4, u64(b_94[24:32])) - b_62 = (*[62]byte)(b_94[32:]) + { + b := b_94[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_62 = (*[62]byte)(b_94[32:]) + } sz_62: - v1 = round(v1, u64(b_62[0:8])) - v2 = round(v2, u64(b_62[8:16])) - v3 = round(v3, u64(b_62[16:24])) - v4 = round(v4, u64(b_62[24:32])) - b_30 = (*[30]byte)(b_62[32:]) + { + b := b_62[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_30 = (*[30]byte)(b_62[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -629,25 +689,55 @@ sz_30: goto sz_30l sz_125: - v1 = round(v1, u64(b_125[0:8])) - v2 = round(v2, u64(b_125[8:16])) - v3 = round(v3, u64(b_125[16:24])) - v4 = round(v4, u64(b_125[24:32])) - b_93 = (*[93]byte)(b_125[32:]) + { + b := b_125[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_93 = (*[93]byte)(b_125[32:]) + } sz_93: - v1 = round(v1, u64(b_93[0:8])) - v2 = round(v2, u64(b_93[8:16])) - v3 = round(v3, u64(b_93[16:24])) - v4 = round(v4, u64(b_93[24:32])) - b_61 = (*[61]byte)(b_93[32:]) + { + b := b_93[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_61 = (*[61]byte)(b_93[32:]) + } sz_61: - v1 = round(v1, u64(b_61[0:8])) - v2 = round(v2, u64(b_61[8:16])) - v3 = round(v3, u64(b_61[16:24])) - v4 = round(v4, u64(b_61[24:32])) - b_29 = (*[29]byte)(b_61[32:]) + { + b := b_61[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_29 = (*[29]byte)(b_61[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -660,25 +750,55 @@ sz_29: goto sz_29l sz_124: - v1 = round(v1, u64(b_124[0:8])) - v2 = round(v2, u64(b_124[8:16])) - v3 = round(v3, u64(b_124[16:24])) - v4 = round(v4, u64(b_124[24:32])) - b_92 = (*[92]byte)(b_124[32:]) + { + b := b_124[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_92 = (*[92]byte)(b_124[32:]) + } sz_92: - v1 = round(v1, u64(b_92[0:8])) - v2 = round(v2, u64(b_92[8:16])) - v3 = round(v3, u64(b_92[16:24])) - v4 = round(v4, u64(b_92[24:32])) - b_60 = (*[60]byte)(b_92[32:]) + { + b := b_92[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_60 = (*[60]byte)(b_92[32:]) + } sz_60: - v1 = round(v1, u64(b_60[0:8])) - v2 = round(v2, u64(b_60[8:16])) - v3 = round(v3, u64(b_60[16:24])) - v4 = round(v4, u64(b_60[24:32])) - b_28 = (*[28]byte)(b_60[32:]) + { + b := b_60[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_28 = (*[28]byte)(b_60[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -691,25 +811,55 @@ sz_28: goto sz_28l sz_123: - v1 = round(v1, u64(b_123[0:8])) - v2 = round(v2, u64(b_123[8:16])) - v3 = round(v3, u64(b_123[16:24])) - v4 = round(v4, u64(b_123[24:32])) - b_91 = (*[91]byte)(b_123[32:]) + { + b := b_123[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_91 = (*[91]byte)(b_123[32:]) + } sz_91: - v1 = round(v1, u64(b_91[0:8])) - v2 = round(v2, u64(b_91[8:16])) - v3 = round(v3, u64(b_91[16:24])) - v4 = round(v4, u64(b_91[24:32])) - b_59 = (*[59]byte)(b_91[32:]) + { + b := b_91[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_59 = (*[59]byte)(b_91[32:]) + } sz_59: - v1 = round(v1, u64(b_59[0:8])) - v2 = round(v2, u64(b_59[8:16])) - v3 = round(v3, u64(b_59[16:24])) - v4 = round(v4, u64(b_59[24:32])) - b_27 = (*[27]byte)(b_59[32:]) + { + b := b_59[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_27 = (*[27]byte)(b_59[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -722,25 +872,55 @@ sz_27: goto sz_27l sz_122: - v1 = round(v1, u64(b_122[0:8])) - v2 = round(v2, u64(b_122[8:16])) - v3 = round(v3, u64(b_122[16:24])) - v4 = round(v4, u64(b_122[24:32])) - b_90 = (*[90]byte)(b_122[32:]) + { + b := b_122[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_90 = (*[90]byte)(b_122[32:]) + } sz_90: - v1 = round(v1, u64(b_90[0:8])) - v2 = round(v2, u64(b_90[8:16])) - v3 = round(v3, u64(b_90[16:24])) - v4 = round(v4, u64(b_90[24:32])) - b_58 = (*[58]byte)(b_90[32:]) + { + b := b_90[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_58 = (*[58]byte)(b_90[32:]) + } sz_58: - v1 = round(v1, u64(b_58[0:8])) - v2 = round(v2, u64(b_58[8:16])) - v3 = round(v3, u64(b_58[16:24])) - v4 = round(v4, u64(b_58[24:32])) - b_26 = (*[26]byte)(b_58[32:]) + { + b := b_58[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_26 = (*[26]byte)(b_58[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -753,25 +933,55 @@ sz_26: goto sz_26l sz_121: - v1 = round(v1, u64(b_121[0:8])) - v2 = round(v2, u64(b_121[8:16])) - v3 = round(v3, u64(b_121[16:24])) - v4 = round(v4, u64(b_121[24:32])) - b_89 = (*[89]byte)(b_121[32:]) + { + b := b_121[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_89 = (*[89]byte)(b_121[32:]) + } sz_89: - v1 = round(v1, u64(b_89[0:8])) - v2 = round(v2, u64(b_89[8:16])) - v3 = round(v3, u64(b_89[16:24])) - v4 = round(v4, u64(b_89[24:32])) - b_57 = (*[57]byte)(b_89[32:]) + { + b := b_89[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_57 = (*[57]byte)(b_89[32:]) + } sz_57: - v1 = round(v1, u64(b_57[0:8])) - v2 = round(v2, u64(b_57[8:16])) - v3 = round(v3, u64(b_57[16:24])) - v4 = round(v4, u64(b_57[24:32])) - b_25 = (*[25]byte)(b_57[32:]) + { + b := b_57[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_25 = (*[25]byte)(b_57[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -784,25 +994,55 @@ sz_25: goto sz_25l sz_120: - v1 = round(v1, u64(b_120[0:8])) - v2 = round(v2, u64(b_120[8:16])) - v3 = round(v3, u64(b_120[16:24])) - v4 = round(v4, u64(b_120[24:32])) - b_88 = (*[88]byte)(b_120[32:]) + { + b := b_120[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_88 = (*[88]byte)(b_120[32:]) + } sz_88: - v1 = round(v1, u64(b_88[0:8])) - v2 = round(v2, u64(b_88[8:16])) - v3 = round(v3, u64(b_88[16:24])) - v4 = round(v4, u64(b_88[24:32])) - b_56 = (*[56]byte)(b_88[32:]) + { + b := b_88[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_56 = (*[56]byte)(b_88[32:]) + } sz_56: - v1 = round(v1, u64(b_56[0:8])) - v2 = round(v2, u64(b_56[8:16])) - v3 = round(v3, u64(b_56[16:24])) - v4 = round(v4, u64(b_56[24:32])) - b_24 = (*[24]byte)(b_56[32:]) + { + b := b_56[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_24 = (*[24]byte)(b_56[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -815,25 +1055,55 @@ sz_24: goto sz_24l sz_119: - v1 = round(v1, u64(b_119[0:8])) - v2 = round(v2, u64(b_119[8:16])) - v3 = round(v3, u64(b_119[16:24])) - v4 = round(v4, u64(b_119[24:32])) - b_87 = (*[87]byte)(b_119[32:]) + { + b := b_119[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_87 = (*[87]byte)(b_119[32:]) + } sz_87: - v1 = round(v1, u64(b_87[0:8])) - v2 = round(v2, u64(b_87[8:16])) - v3 = round(v3, u64(b_87[16:24])) - v4 = round(v4, u64(b_87[24:32])) - b_55 = (*[55]byte)(b_87[32:]) + { + b := b_87[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_55 = (*[55]byte)(b_87[32:]) + } sz_55: - v1 = round(v1, u64(b_55[0:8])) - v2 = round(v2, u64(b_55[8:16])) - v3 = round(v3, u64(b_55[16:24])) - v4 = round(v4, u64(b_55[24:32])) - b_23 = (*[23]byte)(b_55[32:]) + { + b := b_55[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_23 = (*[23]byte)(b_55[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -846,25 +1116,55 @@ sz_23: goto sz_23l sz_118: - v1 = round(v1, u64(b_118[0:8])) - v2 = round(v2, u64(b_118[8:16])) - v3 = round(v3, u64(b_118[16:24])) - v4 = round(v4, u64(b_118[24:32])) - b_86 = (*[86]byte)(b_118[32:]) + { + b := b_118[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_86 = (*[86]byte)(b_118[32:]) + } sz_86: - v1 = round(v1, u64(b_86[0:8])) - v2 = round(v2, u64(b_86[8:16])) - v3 = round(v3, u64(b_86[16:24])) - v4 = round(v4, u64(b_86[24:32])) - b_54 = (*[54]byte)(b_86[32:]) + { + b := b_86[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_54 = (*[54]byte)(b_86[32:]) + } sz_54: - v1 = round(v1, u64(b_54[0:8])) - v2 = round(v2, u64(b_54[8:16])) - v3 = round(v3, u64(b_54[16:24])) - v4 = round(v4, u64(b_54[24:32])) - b_22 = (*[22]byte)(b_54[32:]) + { + b := b_54[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_22 = (*[22]byte)(b_54[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -877,25 +1177,55 @@ sz_22: goto sz_22l sz_117: - v1 = round(v1, u64(b_117[0:8])) - v2 = round(v2, u64(b_117[8:16])) - v3 = round(v3, u64(b_117[16:24])) - v4 = round(v4, u64(b_117[24:32])) - b_85 = (*[85]byte)(b_117[32:]) + { + b := b_117[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_85 = (*[85]byte)(b_117[32:]) + } sz_85: - v1 = round(v1, u64(b_85[0:8])) - v2 = round(v2, u64(b_85[8:16])) - v3 = round(v3, u64(b_85[16:24])) - v4 = round(v4, u64(b_85[24:32])) - b_53 = (*[53]byte)(b_85[32:]) + { + b := b_85[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_53 = (*[53]byte)(b_85[32:]) + } sz_53: - v1 = round(v1, u64(b_53[0:8])) - v2 = round(v2, u64(b_53[8:16])) - v3 = round(v3, u64(b_53[16:24])) - v4 = round(v4, u64(b_53[24:32])) - b_21 = (*[21]byte)(b_53[32:]) + { + b := b_53[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_21 = (*[21]byte)(b_53[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -908,25 +1238,55 @@ sz_21: goto sz_21l sz_116: - v1 = round(v1, u64(b_116[0:8])) - v2 = round(v2, u64(b_116[8:16])) - v3 = round(v3, u64(b_116[16:24])) - v4 = round(v4, u64(b_116[24:32])) - b_84 = (*[84]byte)(b_116[32:]) + { + b := b_116[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_84 = (*[84]byte)(b_116[32:]) + } sz_84: - v1 = round(v1, u64(b_84[0:8])) - v2 = round(v2, u64(b_84[8:16])) - v3 = round(v3, u64(b_84[16:24])) - v4 = round(v4, u64(b_84[24:32])) - b_52 = (*[52]byte)(b_84[32:]) + { + b := b_84[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_52 = (*[52]byte)(b_84[32:]) + } sz_52: - v1 = round(v1, u64(b_52[0:8])) - v2 = round(v2, u64(b_52[8:16])) - v3 = round(v3, u64(b_52[16:24])) - v4 = round(v4, u64(b_52[24:32])) - b_20 = (*[20]byte)(b_52[32:]) + { + b := b_52[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_20 = (*[20]byte)(b_52[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -939,25 +1299,55 @@ sz_20: goto sz_20l sz_115: - v1 = round(v1, u64(b_115[0:8])) - v2 = round(v2, u64(b_115[8:16])) - v3 = round(v3, u64(b_115[16:24])) - v4 = round(v4, u64(b_115[24:32])) - b_83 = (*[83]byte)(b_115[32:]) + { + b := b_115[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_83 = (*[83]byte)(b_115[32:]) + } sz_83: - v1 = round(v1, u64(b_83[0:8])) - v2 = round(v2, u64(b_83[8:16])) - v3 = round(v3, u64(b_83[16:24])) - v4 = round(v4, u64(b_83[24:32])) - b_51 = (*[51]byte)(b_83[32:]) + { + b := b_83[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_51 = (*[51]byte)(b_83[32:]) + } sz_51: - v1 = round(v1, u64(b_51[0:8])) - v2 = round(v2, u64(b_51[8:16])) - v3 = round(v3, u64(b_51[16:24])) - v4 = round(v4, u64(b_51[24:32])) - b_19 = (*[19]byte)(b_51[32:]) + { + b := b_51[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_19 = (*[19]byte)(b_51[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -970,25 +1360,55 @@ sz_19: goto sz_19l sz_114: - v1 = round(v1, u64(b_114[0:8])) - v2 = round(v2, u64(b_114[8:16])) - v3 = round(v3, u64(b_114[16:24])) - v4 = round(v4, u64(b_114[24:32])) - b_82 = (*[82]byte)(b_114[32:]) + { + b := b_114[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_82 = (*[82]byte)(b_114[32:]) + } sz_82: - v1 = round(v1, u64(b_82[0:8])) - v2 = round(v2, u64(b_82[8:16])) - v3 = round(v3, u64(b_82[16:24])) - v4 = round(v4, u64(b_82[24:32])) - b_50 = (*[50]byte)(b_82[32:]) + { + b := b_82[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_50 = (*[50]byte)(b_82[32:]) + } sz_50: - v1 = round(v1, u64(b_50[0:8])) - v2 = round(v2, u64(b_50[8:16])) - v3 = round(v3, u64(b_50[16:24])) - v4 = round(v4, u64(b_50[24:32])) - b_18 = (*[18]byte)(b_50[32:]) + { + b := b_50[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_18 = (*[18]byte)(b_50[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1001,25 +1421,55 @@ sz_18: goto sz_18l sz_113: - v1 = round(v1, u64(b_113[0:8])) - v2 = round(v2, u64(b_113[8:16])) - v3 = round(v3, u64(b_113[16:24])) - v4 = round(v4, u64(b_113[24:32])) - b_81 = (*[81]byte)(b_113[32:]) + { + b := b_113[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_81 = (*[81]byte)(b_113[32:]) + } sz_81: - v1 = round(v1, u64(b_81[0:8])) - v2 = round(v2, u64(b_81[8:16])) - v3 = round(v3, u64(b_81[16:24])) - v4 = round(v4, u64(b_81[24:32])) - b_49 = (*[49]byte)(b_81[32:]) + { + b := b_81[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_49 = (*[49]byte)(b_81[32:]) + } sz_49: - v1 = round(v1, u64(b_49[0:8])) - v2 = round(v2, u64(b_49[8:16])) - v3 = round(v3, u64(b_49[16:24])) - v4 = round(v4, u64(b_49[24:32])) - b_17 = (*[17]byte)(b_49[32:]) + { + b := b_49[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_17 = (*[17]byte)(b_49[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1032,25 +1482,55 @@ sz_17: goto sz_17l sz_112: - v1 = round(v1, u64(b_112[0:8])) - v2 = round(v2, u64(b_112[8:16])) - v3 = round(v3, u64(b_112[16:24])) - v4 = round(v4, u64(b_112[24:32])) - b_80 = (*[80]byte)(b_112[32:]) + { + b := b_112[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_80 = (*[80]byte)(b_112[32:]) + } sz_80: - v1 = round(v1, u64(b_80[0:8])) - v2 = round(v2, u64(b_80[8:16])) - v3 = round(v3, u64(b_80[16:24])) - v4 = round(v4, u64(b_80[24:32])) - b_48 = (*[48]byte)(b_80[32:]) + { + b := b_80[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_48 = (*[48]byte)(b_80[32:]) + } sz_48: - v1 = round(v1, u64(b_48[0:8])) - v2 = round(v2, u64(b_48[8:16])) - v3 = round(v3, u64(b_48[16:24])) - v4 = round(v4, u64(b_48[24:32])) - b_16 = (*[16]byte)(b_48[32:]) + { + b := b_48[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_16 = (*[16]byte)(b_48[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1063,25 +1543,55 @@ sz_16: goto sz_16l sz_111: - v1 = round(v1, u64(b_111[0:8])) - v2 = round(v2, u64(b_111[8:16])) - v3 = round(v3, u64(b_111[16:24])) - v4 = round(v4, u64(b_111[24:32])) - b_79 = (*[79]byte)(b_111[32:]) + { + b := b_111[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_79 = (*[79]byte)(b_111[32:]) + } sz_79: - v1 = round(v1, u64(b_79[0:8])) - v2 = round(v2, u64(b_79[8:16])) - v3 = round(v3, u64(b_79[16:24])) - v4 = round(v4, u64(b_79[24:32])) - b_47 = (*[47]byte)(b_79[32:]) + { + b := b_79[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_47 = (*[47]byte)(b_79[32:]) + } sz_47: - v1 = round(v1, u64(b_47[0:8])) - v2 = round(v2, u64(b_47[8:16])) - v3 = round(v3, u64(b_47[16:24])) - v4 = round(v4, u64(b_47[24:32])) - b_15 = (*[15]byte)(b_47[32:]) + { + b := b_47[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_15 = (*[15]byte)(b_47[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1094,25 +1604,55 @@ sz_15: goto sz_15l sz_110: - v1 = round(v1, u64(b_110[0:8])) - v2 = round(v2, u64(b_110[8:16])) - v3 = round(v3, u64(b_110[16:24])) - v4 = round(v4, u64(b_110[24:32])) - b_78 = (*[78]byte)(b_110[32:]) + { + b := b_110[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_78 = (*[78]byte)(b_110[32:]) + } sz_78: - v1 = round(v1, u64(b_78[0:8])) - v2 = round(v2, u64(b_78[8:16])) - v3 = round(v3, u64(b_78[16:24])) - v4 = round(v4, u64(b_78[24:32])) - b_46 = (*[46]byte)(b_78[32:]) + { + b := b_78[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_46 = (*[46]byte)(b_78[32:]) + } sz_46: - v1 = round(v1, u64(b_46[0:8])) - v2 = round(v2, u64(b_46[8:16])) - v3 = round(v3, u64(b_46[16:24])) - v4 = round(v4, u64(b_46[24:32])) - b_14 = (*[14]byte)(b_46[32:]) + { + b := b_46[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_14 = (*[14]byte)(b_46[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1125,25 +1665,55 @@ sz_14: goto sz_14l sz_109: - v1 = round(v1, u64(b_109[0:8])) - v2 = round(v2, u64(b_109[8:16])) - v3 = round(v3, u64(b_109[16:24])) - v4 = round(v4, u64(b_109[24:32])) - b_77 = (*[77]byte)(b_109[32:]) + { + b := b_109[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_77 = (*[77]byte)(b_109[32:]) + } sz_77: - v1 = round(v1, u64(b_77[0:8])) - v2 = round(v2, u64(b_77[8:16])) - v3 = round(v3, u64(b_77[16:24])) - v4 = round(v4, u64(b_77[24:32])) - b_45 = (*[45]byte)(b_77[32:]) + { + b := b_77[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_45 = (*[45]byte)(b_77[32:]) + } sz_45: - v1 = round(v1, u64(b_45[0:8])) - v2 = round(v2, u64(b_45[8:16])) - v3 = round(v3, u64(b_45[16:24])) - v4 = round(v4, u64(b_45[24:32])) - b_13 = (*[13]byte)(b_45[32:]) + { + b := b_45[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_13 = (*[13]byte)(b_45[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1156,25 +1726,55 @@ sz_13: goto sz_13l sz_108: - v1 = round(v1, u64(b_108[0:8])) - v2 = round(v2, u64(b_108[8:16])) - v3 = round(v3, u64(b_108[16:24])) - v4 = round(v4, u64(b_108[24:32])) - b_76 = (*[76]byte)(b_108[32:]) + { + b := b_108[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_76 = (*[76]byte)(b_108[32:]) + } sz_76: - v1 = round(v1, u64(b_76[0:8])) - v2 = round(v2, u64(b_76[8:16])) - v3 = round(v3, u64(b_76[16:24])) - v4 = round(v4, u64(b_76[24:32])) - b_44 = (*[44]byte)(b_76[32:]) + { + b := b_76[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_44 = (*[44]byte)(b_76[32:]) + } sz_44: - v1 = round(v1, u64(b_44[0:8])) - v2 = round(v2, u64(b_44[8:16])) - v3 = round(v3, u64(b_44[16:24])) - v4 = round(v4, u64(b_44[24:32])) - b_12 = (*[12]byte)(b_44[32:]) + { + b := b_44[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_12 = (*[12]byte)(b_44[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1187,25 +1787,55 @@ sz_12: goto sz_12l sz_107: - v1 = round(v1, u64(b_107[0:8])) - v2 = round(v2, u64(b_107[8:16])) - v3 = round(v3, u64(b_107[16:24])) - v4 = round(v4, u64(b_107[24:32])) - b_75 = (*[75]byte)(b_107[32:]) + { + b := b_107[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_75 = (*[75]byte)(b_107[32:]) + } sz_75: - v1 = round(v1, u64(b_75[0:8])) - v2 = round(v2, u64(b_75[8:16])) - v3 = round(v3, u64(b_75[16:24])) - v4 = round(v4, u64(b_75[24:32])) - b_43 = (*[43]byte)(b_75[32:]) + { + b := b_75[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_43 = (*[43]byte)(b_75[32:]) + } sz_43: - v1 = round(v1, u64(b_43[0:8])) - v2 = round(v2, u64(b_43[8:16])) - v3 = round(v3, u64(b_43[16:24])) - v4 = round(v4, u64(b_43[24:32])) - b_11 = (*[11]byte)(b_43[32:]) + { + b := b_43[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_11 = (*[11]byte)(b_43[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1218,25 +1848,55 @@ sz_11: goto sz_11l sz_106: - v1 = round(v1, u64(b_106[0:8])) - v2 = round(v2, u64(b_106[8:16])) - v3 = round(v3, u64(b_106[16:24])) - v4 = round(v4, u64(b_106[24:32])) - b_74 = (*[74]byte)(b_106[32:]) + { + b := b_106[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_74 = (*[74]byte)(b_106[32:]) + } sz_74: - v1 = round(v1, u64(b_74[0:8])) - v2 = round(v2, u64(b_74[8:16])) - v3 = round(v3, u64(b_74[16:24])) - v4 = round(v4, u64(b_74[24:32])) - b_42 = (*[42]byte)(b_74[32:]) + { + b := b_74[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_42 = (*[42]byte)(b_74[32:]) + } sz_42: - v1 = round(v1, u64(b_42[0:8])) - v2 = round(v2, u64(b_42[8:16])) - v3 = round(v3, u64(b_42[16:24])) - v4 = round(v4, u64(b_42[24:32])) - b_10 = (*[10]byte)(b_42[32:]) + { + b := b_42[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_10 = (*[10]byte)(b_42[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1249,25 +1909,55 @@ sz_10: goto sz_10l sz_105: - v1 = round(v1, u64(b_105[0:8])) - v2 = round(v2, u64(b_105[8:16])) - v3 = round(v3, u64(b_105[16:24])) - v4 = round(v4, u64(b_105[24:32])) - b_73 = (*[73]byte)(b_105[32:]) + { + b := b_105[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_73 = (*[73]byte)(b_105[32:]) + } sz_73: - v1 = round(v1, u64(b_73[0:8])) - v2 = round(v2, u64(b_73[8:16])) - v3 = round(v3, u64(b_73[16:24])) - v4 = round(v4, u64(b_73[24:32])) - b_41 = (*[41]byte)(b_73[32:]) + { + b := b_73[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_41 = (*[41]byte)(b_73[32:]) + } sz_41: - v1 = round(v1, u64(b_41[0:8])) - v2 = round(v2, u64(b_41[8:16])) - v3 = round(v3, u64(b_41[16:24])) - v4 = round(v4, u64(b_41[24:32])) - b_9 = (*[9]byte)(b_41[32:]) + { + b := b_41[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_9 = (*[9]byte)(b_41[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1280,25 +1970,55 @@ sz_9: goto sz_9l sz_104: - v1 = round(v1, u64(b_104[0:8])) - v2 = round(v2, u64(b_104[8:16])) - v3 = round(v3, u64(b_104[16:24])) - v4 = round(v4, u64(b_104[24:32])) - b_72 = (*[72]byte)(b_104[32:]) + { + b := b_104[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_72 = (*[72]byte)(b_104[32:]) + } sz_72: - v1 = round(v1, u64(b_72[0:8])) - v2 = round(v2, u64(b_72[8:16])) - v3 = round(v3, u64(b_72[16:24])) - v4 = round(v4, u64(b_72[24:32])) - b_40 = (*[40]byte)(b_72[32:]) + { + b := b_72[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_40 = (*[40]byte)(b_72[32:]) + } sz_40: - v1 = round(v1, u64(b_40[0:8])) - v2 = round(v2, u64(b_40[8:16])) - v3 = round(v3, u64(b_40[16:24])) - v4 = round(v4, u64(b_40[24:32])) - b_8 = (*[8]byte)(b_40[32:]) + { + b := b_40[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_8 = (*[8]byte)(b_40[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1311,25 +2031,55 @@ sz_8: goto sz_8l sz_103: - v1 = round(v1, u64(b_103[0:8])) - v2 = round(v2, u64(b_103[8:16])) - v3 = round(v3, u64(b_103[16:24])) - v4 = round(v4, u64(b_103[24:32])) - b_71 = (*[71]byte)(b_103[32:]) + { + b := b_103[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_71 = (*[71]byte)(b_103[32:]) + } sz_71: - v1 = round(v1, u64(b_71[0:8])) - v2 = round(v2, u64(b_71[8:16])) - v3 = round(v3, u64(b_71[16:24])) - v4 = round(v4, u64(b_71[24:32])) - b_39 = (*[39]byte)(b_71[32:]) + { + b := b_71[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_39 = (*[39]byte)(b_71[32:]) + } sz_39: - v1 = round(v1, u64(b_39[0:8])) - v2 = round(v2, u64(b_39[8:16])) - v3 = round(v3, u64(b_39[16:24])) - v4 = round(v4, u64(b_39[24:32])) - b_7 = (*[7]byte)(b_39[32:]) + { + b := b_39[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_7 = (*[7]byte)(b_39[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1342,25 +2092,55 @@ sz_7: goto sz_7l sz_102: - v1 = round(v1, u64(b_102[0:8])) - v2 = round(v2, u64(b_102[8:16])) - v3 = round(v3, u64(b_102[16:24])) - v4 = round(v4, u64(b_102[24:32])) - b_70 = (*[70]byte)(b_102[32:]) + { + b := b_102[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_70 = (*[70]byte)(b_102[32:]) + } sz_70: - v1 = round(v1, u64(b_70[0:8])) - v2 = round(v2, u64(b_70[8:16])) - v3 = round(v3, u64(b_70[16:24])) - v4 = round(v4, u64(b_70[24:32])) - b_38 = (*[38]byte)(b_70[32:]) + { + b := b_70[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_38 = (*[38]byte)(b_70[32:]) + } sz_38: - v1 = round(v1, u64(b_38[0:8])) - v2 = round(v2, u64(b_38[8:16])) - v3 = round(v3, u64(b_38[16:24])) - v4 = round(v4, u64(b_38[24:32])) - b_6 = (*[6]byte)(b_38[32:]) + { + b := b_38[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_6 = (*[6]byte)(b_38[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1373,25 +2153,55 @@ sz_6: goto sz_6l sz_101: - v1 = round(v1, u64(b_101[0:8])) - v2 = round(v2, u64(b_101[8:16])) - v3 = round(v3, u64(b_101[16:24])) - v4 = round(v4, u64(b_101[24:32])) - b_69 = (*[69]byte)(b_101[32:]) + { + b := b_101[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_69 = (*[69]byte)(b_101[32:]) + } sz_69: - v1 = round(v1, u64(b_69[0:8])) - v2 = round(v2, u64(b_69[8:16])) - v3 = round(v3, u64(b_69[16:24])) - v4 = round(v4, u64(b_69[24:32])) - b_37 = (*[37]byte)(b_69[32:]) + { + b := b_69[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_37 = (*[37]byte)(b_69[32:]) + } sz_37: - v1 = round(v1, u64(b_37[0:8])) - v2 = round(v2, u64(b_37[8:16])) - v3 = round(v3, u64(b_37[16:24])) - v4 = round(v4, u64(b_37[24:32])) - b_5 = (*[5]byte)(b_37[32:]) + { + b := b_37[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_5 = (*[5]byte)(b_37[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1404,25 +2214,55 @@ sz_5: goto sz_5l sz_100: - v1 = round(v1, u64(b_100[0:8])) - v2 = round(v2, u64(b_100[8:16])) - v3 = round(v3, u64(b_100[16:24])) - v4 = round(v4, u64(b_100[24:32])) - b_68 = (*[68]byte)(b_100[32:]) + { + b := b_100[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_68 = (*[68]byte)(b_100[32:]) + } sz_68: - v1 = round(v1, u64(b_68[0:8])) - v2 = round(v2, u64(b_68[8:16])) - v3 = round(v3, u64(b_68[16:24])) - v4 = round(v4, u64(b_68[24:32])) - b_36 = (*[36]byte)(b_68[32:]) + { + b := b_68[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_36 = (*[36]byte)(b_68[32:]) + } sz_36: - v1 = round(v1, u64(b_36[0:8])) - v2 = round(v2, u64(b_36[8:16])) - v3 = round(v3, u64(b_36[16:24])) - v4 = round(v4, u64(b_36[24:32])) - b_4 = (*[4]byte)(b_36[32:]) + { + b := b_36[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_4 = (*[4]byte)(b_36[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1435,25 +2275,55 @@ sz_4: goto sz_4l sz_99: - v1 = round(v1, u64(b_99[0:8])) - v2 = round(v2, u64(b_99[8:16])) - v3 = round(v3, u64(b_99[16:24])) - v4 = round(v4, u64(b_99[24:32])) - b_67 = (*[67]byte)(b_99[32:]) + { + b := b_99[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_67 = (*[67]byte)(b_99[32:]) + } sz_67: - v1 = round(v1, u64(b_67[0:8])) - v2 = round(v2, u64(b_67[8:16])) - v3 = round(v3, u64(b_67[16:24])) - v4 = round(v4, u64(b_67[24:32])) - b_35 = (*[35]byte)(b_67[32:]) + { + b := b_67[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_35 = (*[35]byte)(b_67[32:]) + } sz_35: - v1 = round(v1, u64(b_35[0:8])) - v2 = round(v2, u64(b_35[8:16])) - v3 = round(v3, u64(b_35[16:24])) - v4 = round(v4, u64(b_35[24:32])) - b_3 = (*[3]byte)(b_35[32:]) + { + b := b_35[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_3 = (*[3]byte)(b_35[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1466,25 +2336,55 @@ sz_3: goto sz_3l sz_98: - v1 = round(v1, u64(b_98[0:8])) - v2 = round(v2, u64(b_98[8:16])) - v3 = round(v3, u64(b_98[16:24])) - v4 = round(v4, u64(b_98[24:32])) - b_66 = (*[66]byte)(b_98[32:]) + { + b := b_98[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_66 = (*[66]byte)(b_98[32:]) + } sz_66: - v1 = round(v1, u64(b_66[0:8])) - v2 = round(v2, u64(b_66[8:16])) - v3 = round(v3, u64(b_66[16:24])) - v4 = round(v4, u64(b_66[24:32])) - b_34 = (*[34]byte)(b_66[32:]) + { + b := b_66[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_34 = (*[34]byte)(b_66[32:]) + } sz_34: - v1 = round(v1, u64(b_34[0:8])) - v2 = round(v2, u64(b_34[8:16])) - v3 = round(v3, u64(b_34[16:24])) - v4 = round(v4, u64(b_34[24:32])) - b_2 = (*[2]byte)(b_34[32:]) + { + b := b_34[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_2 = (*[2]byte)(b_34[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1497,25 +2397,55 @@ sz_2: goto sz_2l sz_97: - v1 = round(v1, u64(b_97[0:8])) - v2 = round(v2, u64(b_97[8:16])) - v3 = round(v3, u64(b_97[16:24])) - v4 = round(v4, u64(b_97[24:32])) - b_65 = (*[65]byte)(b_97[32:]) + { + b := b_97[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_65 = (*[65]byte)(b_97[32:]) + } sz_65: - v1 = round(v1, u64(b_65[0:8])) - v2 = round(v2, u64(b_65[8:16])) - v3 = round(v3, u64(b_65[16:24])) - v4 = round(v4, u64(b_65[24:32])) - b_33 = (*[33]byte)(b_65[32:]) + { + b := b_65[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_33 = (*[33]byte)(b_65[32:]) + } sz_33: - v1 = round(v1, u64(b_33[0:8])) - v2 = round(v2, u64(b_33[8:16])) - v3 = round(v3, u64(b_33[16:24])) - v4 = round(v4, u64(b_33[24:32])) - b_1 = (*[1]byte)(b_33[32:]) + { + b := b_33[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_1 = (*[1]byte)(b_33[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1528,25 +2458,55 @@ sz_1: goto sz_1l sz_96: - v1 = round(v1, u64(b_96[0:8])) - v2 = round(v2, u64(b_96[8:16])) - v3 = round(v3, u64(b_96[16:24])) - v4 = round(v4, u64(b_96[24:32])) - b_64 = (*[64]byte)(b_96[32:]) + { + b := b_96[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_64 = (*[64]byte)(b_96[32:]) + } sz_64: - v1 = round(v1, u64(b_64[0:8])) - v2 = round(v2, u64(b_64[8:16])) - v3 = round(v3, u64(b_64[16:24])) - v4 = round(v4, u64(b_64[24:32])) - b_32 = (*[32]byte)(b_64[32:]) + { + b := b_64[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_32 = (*[32]byte)(b_64[32:]) + } sz_32: - v1 = round(v1, u64(b_32[0:8])) - v2 = round(v2, u64(b_32[8:16])) - v3 = round(v3, u64(b_32[16:24])) - v4 = round(v4, u64(b_32[24:32])) - b_0 = (*[0]byte)(b_32[32:]) + { + b := b_32[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v1 = round(v1, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v2 = round(v2, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + b = b[8:] + v3 = round(v3, load) + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + v4 = round(v4, load) + b_0 = (*[0]byte)(b_32[32:]) + } h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) h = mergeRound(h, v1) @@ -1559,165 +2519,277 @@ sz_32: // Theses are 8 bytes block trailing slides. sz_31l: - h ^= round(0, u64(b_31[:8])) - h = rol27(h)*prime1 + prime4 - b_23 = (*[23]byte)(b_31[8:]) + { + b := b_31[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_23 = (*[23]byte)(b_31[8:]) + } sz_23l: - h ^= round(0, u64(b_23[:8])) - h = rol27(h)*prime1 + prime4 - b_15 = (*[15]byte)(b_23[8:]) + { + b := b_23[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_15 = (*[15]byte)(b_23[8:]) + } sz_15l: - h ^= round(0, u64(b_15[:8])) - h = rol27(h)*prime1 + prime4 - b_7 = (*[7]byte)(b_15[8:]) + { + b := b_15[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_7 = (*[7]byte)(b_15[8:]) + } goto sz_7l sz_30l: - h ^= round(0, u64(b_30[:8])) - h = rol27(h)*prime1 + prime4 - b_22 = (*[22]byte)(b_30[8:]) + { + b := b_30[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_22 = (*[22]byte)(b_30[8:]) + } sz_22l: - h ^= round(0, u64(b_22[:8])) - h = rol27(h)*prime1 + prime4 - b_14 = (*[14]byte)(b_22[8:]) + { + b := b_22[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_14 = (*[14]byte)(b_22[8:]) + } sz_14l: - h ^= round(0, u64(b_14[:8])) - h = rol27(h)*prime1 + prime4 - b_6 = (*[6]byte)(b_14[8:]) + { + b := b_14[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_6 = (*[6]byte)(b_14[8:]) + } goto sz_6l sz_29l: - h ^= round(0, u64(b_29[:8])) - h = rol27(h)*prime1 + prime4 - b_21 = (*[21]byte)(b_29[8:]) + { + b := b_29[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_21 = (*[21]byte)(b_29[8:]) + } sz_21l: - h ^= round(0, u64(b_21[:8])) - h = rol27(h)*prime1 + prime4 - b_13 = (*[13]byte)(b_21[8:]) + { + b := b_21[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_13 = (*[13]byte)(b_21[8:]) + } sz_13l: - h ^= round(0, u64(b_13[:8])) - h = rol27(h)*prime1 + prime4 - b_5 = (*[5]byte)(b_13[8:]) + { + b := b_13[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_5 = (*[5]byte)(b_13[8:]) + } goto sz_5l sz_28l: - h ^= round(0, u64(b_28[:8])) - h = rol27(h)*prime1 + prime4 - b_20 = (*[20]byte)(b_28[8:]) + { + b := b_28[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_20 = (*[20]byte)(b_28[8:]) + } sz_20l: - h ^= round(0, u64(b_20[:8])) - h = rol27(h)*prime1 + prime4 - b_12 = (*[12]byte)(b_20[8:]) + { + b := b_20[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_12 = (*[12]byte)(b_20[8:]) + } sz_12l: - h ^= round(0, u64(b_12[:8])) - h = rol27(h)*prime1 + prime4 - b_4 = (*[4]byte)(b_12[8:]) + { + b := b_12[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_4 = (*[4]byte)(b_12[8:]) + } goto sz_4l sz_27l: - h ^= round(0, u64(b_27[:8])) - h = rol27(h)*prime1 + prime4 - b_19 = (*[19]byte)(b_27[8:]) + { + b := b_27[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_19 = (*[19]byte)(b_27[8:]) + } sz_19l: - h ^= round(0, u64(b_19[:8])) - h = rol27(h)*prime1 + prime4 - b_11 = (*[11]byte)(b_19[8:]) + { + b := b_19[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_11 = (*[11]byte)(b_19[8:]) + } sz_11l: - h ^= round(0, u64(b_11[:8])) - h = rol27(h)*prime1 + prime4 - b_3 = (*[3]byte)(b_11[8:]) + { + b := b_11[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_3 = (*[3]byte)(b_11[8:]) + } goto sz_3l sz_26l: - h ^= round(0, u64(b_26[:8])) - h = rol27(h)*prime1 + prime4 - b_18 = (*[18]byte)(b_26[8:]) + { + b := b_26[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_18 = (*[18]byte)(b_26[8:]) + } sz_18l: - h ^= round(0, u64(b_18[:8])) - h = rol27(h)*prime1 + prime4 - b_10 = (*[10]byte)(b_18[8:]) + { + b := b_18[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_10 = (*[10]byte)(b_18[8:]) + } sz_10l: - h ^= round(0, u64(b_10[:8])) - h = rol27(h)*prime1 + prime4 - b_2 = (*[2]byte)(b_10[8:]) + { + b := b_10[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_2 = (*[2]byte)(b_10[8:]) + } goto sz_2l sz_25l: - h ^= round(0, u64(b_25[:8])) - h = rol27(h)*prime1 + prime4 - b_17 = (*[17]byte)(b_25[8:]) + { + b := b_25[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_17 = (*[17]byte)(b_25[8:]) + } sz_17l: - h ^= round(0, u64(b_17[:8])) - h = rol27(h)*prime1 + prime4 - b_9 = (*[9]byte)(b_17[8:]) + { + b := b_17[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_9 = (*[9]byte)(b_17[8:]) + } sz_9l: - h ^= round(0, u64(b_9[:8])) - h = rol27(h)*prime1 + prime4 - b_1 = (*[1]byte)(b_9[8:]) + { + b := b_9[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_1 = (*[1]byte)(b_9[8:]) + } goto sz_1l sz_24l: - h ^= round(0, u64(b_24[:8])) - h = rol27(h)*prime1 + prime4 - b_16 = (*[16]byte)(b_24[8:]) + { + b := b_24[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_16 = (*[16]byte)(b_24[8:]) + } sz_16l: - h ^= round(0, u64(b_16[:8])) - h = rol27(h)*prime1 + prime4 - b_8 = (*[8]byte)(b_16[8:]) + { + b := b_16[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_8 = (*[8]byte)(b_16[8:]) + } sz_8l: - h ^= round(0, u64(b_8[:8])) - h = rol27(h)*prime1 + prime4 - b_0 = (*[0]byte)(b_8[8:]) + { + b := b_8[:] + load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + h ^= round(0, load) + h = rol27(h)*prime1 + prime4 + b_0 = (*[0]byte)(b_8[8:]) + } goto sz_0l // Theses are the 4 bytes trailing slides. sz_7l: - h ^= uint64(u32(b_7[:4])) * prime1 - h = rol23(h)*prime2 + prime3 - b_3 = (*[3]byte)(b_7[4:]) - goto sz_3l + { + b := b_7[:] + load := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 // Work around for go.dev/issue/68081. + h ^= uint64(load) * prime1 + h = rol23(h)*prime2 + prime3 + b_3 = (*[3]byte)(b_7[4:]) + goto sz_3l + } sz_6l: - h ^= uint64(u32(b_6[:4])) * prime1 - h = rol23(h)*prime2 + prime3 - b_2 = (*[2]byte)(b_6[4:]) - goto sz_2l + { + b := b_6[:] + load := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 // Work around for go.dev/issue/68081. + h ^= uint64(load) * prime1 + h = rol23(h)*prime2 + prime3 + b_2 = (*[2]byte)(b_6[4:]) + goto sz_2l + } sz_5l: - h ^= uint64(u32(b_5[:4])) * prime1 - h = rol23(h)*prime2 + prime3 - b_1 = (*[1]byte)(b_5[4:]) - goto sz_1l + { + b := b_5[:] + load := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 // Work around for go.dev/issue/68081. + h ^= uint64(load) * prime1 + h = rol23(h)*prime2 + prime3 + b_1 = (*[1]byte)(b_5[4:]) + goto sz_1l + } sz_4l: - h ^= uint64(u32(b_4[:4])) * prime1 - h = rol23(h)*prime2 + prime3 - b_0 = (*[0]byte)(b_4[4:]) - goto sz_0l + { + b := b_4[:] + load := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 // Work around for go.dev/issue/68081. + h ^= uint64(load) * prime1 + h = rol23(h)*prime2 + prime3 + b_0 = (*[0]byte)(b_4[4:]) + goto sz_0l + } // This is the 1 bytes trailing slide. sz_3l: From 907c96d90a3429736fa833c1e70d55996384a9f1 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Thu, 20 Jun 2024 08:39:47 +0200 Subject: [PATCH 12/16] fix file leak in gen/slide.go This didn't impacted anything since the process would exit right away, but we would like the file if w.WriteTo failed. --- gen/slide.go | 1 + 1 file changed, 1 insertion(+) diff --git a/gen/slide.go b/gen/slide.go index f0511dd..b29b7ba 100644 --- a/gen/slide.go +++ b/gen/slide.go @@ -193,6 +193,7 @@ sz_0l: if err != nil { return err } + defer f.Close() _, err = w.WriteTo(f) if err != nil { os.Remove(path) From a0584e243456f1c093752d9c4b3dba40e2f3de41 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Thu, 20 Jun 2024 09:15:50 +0200 Subject: [PATCH 13/16] manually inline functions in the slide This makes the slide faster than anything else on most inputs. Extremely small inputs are slower but by little. --- gen/slide.go | 75 +- xxhash_slide.go | 3537 ++++++++++++++++++++++++++++++++++++----------- 2 files changed, 2797 insertions(+), 815 deletions(-) diff --git a/gen/slide.go b/gen/slide.go index b29b7ba..84384b7 100644 --- a/gen/slide.go +++ b/gen/slide.go @@ -4,6 +4,7 @@ import ( "bytes" "fmt" "os" + "strings" ) const sumSlideSize = 127 @@ -17,6 +18,8 @@ func slide() error { package xxhash +import "math/bits" + // Generated by gen/slide.go. DO NOT EDIT. const slideLength = %d @@ -38,6 +41,7 @@ func slide(b []byte) uint64 { // This means I make very liberal use of goto, they shouldn't be red as JMPs but abstract basic blocks links. // - The compiler has some SSA passes. // This is used for all the b_* tricks. + // - We can't trust the compiler to inline anything (except intrinsics). // Setup variables here since go doesn't want use to do dangerous gotos. v1 := prime1 @@ -92,32 +96,28 @@ func slide(b []byte) uint64 { fmt.Fprintf(w, `sz_%d: { b := b_%d[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 = round(v1, load) - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 = round(v2, load) - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 +`, i, i) + for r := 1; r <= 4; r++ { + fmt.Fprintf(w, ` load = %s b = b[8:] - v3 = round(v3, load) - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_%d = (*[%d]byte)(b_%d[32:]) +`, load64) + genRound(w, 2, fmt.Sprintf("v%d", r), "load") + } + fmt.Fprintf(w, `b_%d = (*[%d]byte)(b_%d[32:]) } -`, i, i, i-32, i-32, i) +`, i-32, i-32, i) // POTENTIAL OPTIMIZATION: b[32:] creates an addition to bump the pointer which means the address dependency on the memory loads is not resolved before the jmp table. I know two fixes: // - change b to a pointer to the end of the slice and subtract the total offset. I don't know how to do this in pure go. // - don't bother reusing the slides, this means each load instruction can hardcode the offset. Make the code significantly bigger and i-cache worst, altho I didn't tried it. } - w.WriteString(` h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) - + w.WriteString(` h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) `) + for r := 1; r <= 4; r++ { + genMergeRound(w, 1, "h", fmt.Sprintf("v%d", r)) + } + w.WriteString("\n") if i != 0 { // Avoid « label sz_0 defined and not used », case 0 shortcuts with a precomputed value. fmt.Fprintf(w, "sz_%d:\n", i) } @@ -134,13 +134,16 @@ func slide(b []byte) uint64 { fmt.Fprintf(w, `sz_%dl: { b := b_%d[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + load := %s + var temp uint64 +`, i, i, load64) + genRound(w, 2, "temp", "load") + fmt.Fprintf(w, `h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_%d = (*[%d]byte)(b_%d[8:]) } -`, i, i, i-8, i-8, i) +`, i-8, i-8, i) } fmt.Fprintf(w, `goto sz_%dl @@ -155,7 +158,7 @@ func slide(b []byte) uint64 { b := b_%d[:] load := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 // Work around for go.dev/issue/68081. h ^= uint64(load) * prime1 - h = rol23(h)*prime2 + prime3 + h = bits.RotateLeft64(h, 23)*prime2 + prime3 b_%d = (*[%d]byte)(b_%d[4:]) goto sz_%dl } @@ -168,7 +171,7 @@ func slide(b []byte) uint64 { i-- fmt.Fprintf(w, `sz_%dl: h ^= uint64(b_%d[0]) * prime5 - h = rol11(h) * prime1 + h = bits.RotateLeft64(h, 11) * prime1 b_%d = (*[%d]byte)(b_%d[1:]) `, i, i, i-1, i-1, i) @@ -207,3 +210,27 @@ sz_0l: return nil } + +func genRound(w *bytes.Buffer, tab uint, acc, input string) { + tabs := strings.Repeat("\t", int(tab)) + fmt.Fprintf(w, `%s%s += %s * prime2 +%s%s = bits.RotateLeft64(%s, 31) +%s%s *= prime1 +`, tabs, acc, input, tabs, acc, acc, tabs, acc) +} + +func genMergeRound(w *bytes.Buffer, tab uint, acc, val string) { + tabs := strings.Repeat("\t", int(tab)) + tab++ + tabsp := strings.Repeat("\t", int(tab)) + fmt.Fprintf(w, `%s{ +%svar temp uint64 +`, tabs, tabsp) + genRound(w, tab, "temp", val) + fmt.Fprintf(w, `%s%s ^= temp +%s%s = %s*prime1 + prime4 +%s} +`, tabsp, acc, tabsp, acc, acc, tabs) +} + +const load64 = "uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081." diff --git a/xxhash_slide.go b/xxhash_slide.go index bc265e8..64b962c 100644 --- a/xxhash_slide.go +++ b/xxhash_slide.go @@ -3,6 +3,8 @@ package xxhash +import "math/bits" + // Generated by gen/slide.go. DO NOT EDIT. const slideLength = 127 @@ -24,6 +26,7 @@ func slide(b []byte) uint64 { // This means I make very liberal use of goto, they shouldn't be red as JMPs but abstract basic blocks links. // - The compiler has some SSA passes. // This is used for all the b_* tricks. + // - We can't trust the compiler to inline anything (except intrinsics). // Setup variables here since go doesn't want use to do dangerous gotos. v1 := prime1 @@ -569,59 +572,117 @@ func slide(b []byte) uint64 { sz_127: { b := b_127[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_95 = (*[95]byte)(b_127[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_95 = (*[95]byte)(b_127[32:]) } sz_95: { b := b_95[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_63 = (*[63]byte)(b_95[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_63 = (*[63]byte)(b_95[32:]) } sz_63: { b := b_63[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_31 = (*[31]byte)(b_63[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_31 = (*[31]byte)(b_63[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_31: h += n @@ -630,59 +691,117 @@ sz_31: sz_126: { b := b_126[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_94 = (*[94]byte)(b_126[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_94 = (*[94]byte)(b_126[32:]) } sz_94: { b := b_94[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_62 = (*[62]byte)(b_94[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_62 = (*[62]byte)(b_94[32:]) } sz_62: { b := b_62[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_30 = (*[30]byte)(b_62[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_30 = (*[30]byte)(b_62[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_30: h += n @@ -691,59 +810,117 @@ sz_30: sz_125: { b := b_125[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_93 = (*[93]byte)(b_125[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_93 = (*[93]byte)(b_125[32:]) } sz_93: { b := b_93[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_61 = (*[61]byte)(b_93[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_61 = (*[61]byte)(b_93[32:]) } sz_61: { b := b_61[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_29 = (*[29]byte)(b_61[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_29 = (*[29]byte)(b_61[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_29: h += n @@ -752,59 +929,117 @@ sz_29: sz_124: { b := b_124[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_92 = (*[92]byte)(b_124[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_92 = (*[92]byte)(b_124[32:]) } sz_92: { b := b_92[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_60 = (*[60]byte)(b_92[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_60 = (*[60]byte)(b_92[32:]) } sz_60: { b := b_60[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_28 = (*[28]byte)(b_60[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_28 = (*[28]byte)(b_60[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_28: h += n @@ -813,59 +1048,117 @@ sz_28: sz_123: { b := b_123[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_91 = (*[91]byte)(b_123[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_91 = (*[91]byte)(b_123[32:]) } sz_91: { b := b_91[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_59 = (*[59]byte)(b_91[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_59 = (*[59]byte)(b_91[32:]) } sz_59: { b := b_59[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_27 = (*[27]byte)(b_59[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_27 = (*[27]byte)(b_59[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_27: h += n @@ -874,59 +1167,117 @@ sz_27: sz_122: { b := b_122[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_90 = (*[90]byte)(b_122[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_90 = (*[90]byte)(b_122[32:]) } sz_90: { b := b_90[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_58 = (*[58]byte)(b_90[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_58 = (*[58]byte)(b_90[32:]) } sz_58: { b := b_58[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_26 = (*[26]byte)(b_58[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_26 = (*[26]byte)(b_58[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_26: h += n @@ -935,59 +1286,117 @@ sz_26: sz_121: { b := b_121[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_89 = (*[89]byte)(b_121[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_89 = (*[89]byte)(b_121[32:]) } sz_89: { b := b_89[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_57 = (*[57]byte)(b_89[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_57 = (*[57]byte)(b_89[32:]) } sz_57: { b := b_57[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_25 = (*[25]byte)(b_57[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_25 = (*[25]byte)(b_57[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_25: h += n @@ -996,59 +1405,117 @@ sz_25: sz_120: { b := b_120[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_88 = (*[88]byte)(b_120[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_88 = (*[88]byte)(b_120[32:]) } sz_88: { b := b_88[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_56 = (*[56]byte)(b_88[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_56 = (*[56]byte)(b_88[32:]) } sz_56: { b := b_56[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_24 = (*[24]byte)(b_56[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_24 = (*[24]byte)(b_56[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_24: h += n @@ -1057,59 +1524,117 @@ sz_24: sz_119: { b := b_119[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_87 = (*[87]byte)(b_119[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_87 = (*[87]byte)(b_119[32:]) } sz_87: { b := b_87[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_55 = (*[55]byte)(b_87[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_55 = (*[55]byte)(b_87[32:]) } sz_55: { b := b_55[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_23 = (*[23]byte)(b_55[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_23 = (*[23]byte)(b_55[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_23: h += n @@ -1118,59 +1643,117 @@ sz_23: sz_118: { b := b_118[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_86 = (*[86]byte)(b_118[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_86 = (*[86]byte)(b_118[32:]) } sz_86: { b := b_86[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_54 = (*[54]byte)(b_86[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_54 = (*[54]byte)(b_86[32:]) } sz_54: { b := b_54[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_22 = (*[22]byte)(b_54[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_22 = (*[22]byte)(b_54[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_22: h += n @@ -1179,59 +1762,117 @@ sz_22: sz_117: { b := b_117[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_85 = (*[85]byte)(b_117[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_85 = (*[85]byte)(b_117[32:]) } sz_85: { b := b_85[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_53 = (*[53]byte)(b_85[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_53 = (*[53]byte)(b_85[32:]) } sz_53: { b := b_53[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_21 = (*[21]byte)(b_53[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_21 = (*[21]byte)(b_53[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_21: h += n @@ -1240,59 +1881,117 @@ sz_21: sz_116: { b := b_116[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_84 = (*[84]byte)(b_116[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_84 = (*[84]byte)(b_116[32:]) } sz_84: { b := b_84[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_52 = (*[52]byte)(b_84[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_52 = (*[52]byte)(b_84[32:]) } sz_52: { b := b_52[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_20 = (*[20]byte)(b_52[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_20 = (*[20]byte)(b_52[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_20: h += n @@ -1301,59 +2000,117 @@ sz_20: sz_115: { b := b_115[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_83 = (*[83]byte)(b_115[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_83 = (*[83]byte)(b_115[32:]) } sz_83: { b := b_83[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_51 = (*[51]byte)(b_83[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_51 = (*[51]byte)(b_83[32:]) } sz_51: { b := b_51[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_19 = (*[19]byte)(b_51[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_19 = (*[19]byte)(b_51[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_19: h += n @@ -1362,59 +2119,117 @@ sz_19: sz_114: { b := b_114[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_82 = (*[82]byte)(b_114[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_82 = (*[82]byte)(b_114[32:]) } sz_82: { b := b_82[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_50 = (*[50]byte)(b_82[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_50 = (*[50]byte)(b_82[32:]) } sz_50: { b := b_50[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_18 = (*[18]byte)(b_50[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_18 = (*[18]byte)(b_50[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_18: h += n @@ -1423,59 +2238,117 @@ sz_18: sz_113: { b := b_113[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_81 = (*[81]byte)(b_113[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_81 = (*[81]byte)(b_113[32:]) } sz_81: { b := b_81[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_49 = (*[49]byte)(b_81[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_49 = (*[49]byte)(b_81[32:]) } sz_49: { b := b_49[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_17 = (*[17]byte)(b_49[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_17 = (*[17]byte)(b_49[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_17: h += n @@ -1484,59 +2357,117 @@ sz_17: sz_112: { b := b_112[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_80 = (*[80]byte)(b_112[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_80 = (*[80]byte)(b_112[32:]) } sz_80: { b := b_80[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_48 = (*[48]byte)(b_80[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_48 = (*[48]byte)(b_80[32:]) } sz_48: { b := b_48[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_16 = (*[16]byte)(b_48[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_16 = (*[16]byte)(b_48[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_16: h += n @@ -1545,59 +2476,117 @@ sz_16: sz_111: { b := b_111[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_79 = (*[79]byte)(b_111[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_79 = (*[79]byte)(b_111[32:]) } sz_79: { b := b_79[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_47 = (*[47]byte)(b_79[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_47 = (*[47]byte)(b_79[32:]) } sz_47: { b := b_47[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_15 = (*[15]byte)(b_47[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_15 = (*[15]byte)(b_47[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_15: h += n @@ -1606,59 +2595,117 @@ sz_15: sz_110: { b := b_110[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_78 = (*[78]byte)(b_110[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_78 = (*[78]byte)(b_110[32:]) } sz_78: { b := b_78[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_46 = (*[46]byte)(b_78[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_46 = (*[46]byte)(b_78[32:]) } sz_46: { b := b_46[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_14 = (*[14]byte)(b_46[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_14 = (*[14]byte)(b_46[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_14: h += n @@ -1667,59 +2714,117 @@ sz_14: sz_109: { b := b_109[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_77 = (*[77]byte)(b_109[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_77 = (*[77]byte)(b_109[32:]) } sz_77: { b := b_77[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_45 = (*[45]byte)(b_77[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_45 = (*[45]byte)(b_77[32:]) } sz_45: { b := b_45[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_13 = (*[13]byte)(b_45[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_13 = (*[13]byte)(b_45[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_13: h += n @@ -1728,59 +2833,117 @@ sz_13: sz_108: { b := b_108[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_76 = (*[76]byte)(b_108[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_76 = (*[76]byte)(b_108[32:]) } sz_76: { b := b_76[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_44 = (*[44]byte)(b_76[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_44 = (*[44]byte)(b_76[32:]) } sz_44: { b := b_44[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_12 = (*[12]byte)(b_44[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_12 = (*[12]byte)(b_44[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_12: h += n @@ -1789,59 +2952,117 @@ sz_12: sz_107: { b := b_107[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_75 = (*[75]byte)(b_107[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_75 = (*[75]byte)(b_107[32:]) } sz_75: { b := b_75[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_43 = (*[43]byte)(b_75[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_43 = (*[43]byte)(b_75[32:]) } sz_43: { b := b_43[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_11 = (*[11]byte)(b_43[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_11 = (*[11]byte)(b_43[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_11: h += n @@ -1850,59 +3071,117 @@ sz_11: sz_106: { b := b_106[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_74 = (*[74]byte)(b_106[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_74 = (*[74]byte)(b_106[32:]) } sz_74: { b := b_74[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_42 = (*[42]byte)(b_74[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_42 = (*[42]byte)(b_74[32:]) } sz_42: { b := b_42[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_10 = (*[10]byte)(b_42[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_10 = (*[10]byte)(b_42[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_10: h += n @@ -1911,59 +3190,117 @@ sz_10: sz_105: { b := b_105[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_73 = (*[73]byte)(b_105[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_73 = (*[73]byte)(b_105[32:]) } sz_73: { b := b_73[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_41 = (*[41]byte)(b_73[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_41 = (*[41]byte)(b_73[32:]) } sz_41: { b := b_41[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_9 = (*[9]byte)(b_41[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_9 = (*[9]byte)(b_41[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_9: h += n @@ -1972,59 +3309,117 @@ sz_9: sz_104: { b := b_104[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_72 = (*[72]byte)(b_104[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_72 = (*[72]byte)(b_104[32:]) } sz_72: { b := b_72[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_40 = (*[40]byte)(b_72[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_40 = (*[40]byte)(b_72[32:]) } sz_40: { b := b_40[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_8 = (*[8]byte)(b_40[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_8 = (*[8]byte)(b_40[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_8: h += n @@ -2033,59 +3428,117 @@ sz_8: sz_103: { b := b_103[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_71 = (*[71]byte)(b_103[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_71 = (*[71]byte)(b_103[32:]) } sz_71: { b := b_71[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_39 = (*[39]byte)(b_71[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_39 = (*[39]byte)(b_71[32:]) } sz_39: { b := b_39[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_7 = (*[7]byte)(b_39[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_7 = (*[7]byte)(b_39[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_7: h += n @@ -2094,59 +3547,117 @@ sz_7: sz_102: { b := b_102[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_70 = (*[70]byte)(b_102[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_70 = (*[70]byte)(b_102[32:]) } sz_70: { b := b_70[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_38 = (*[38]byte)(b_70[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_38 = (*[38]byte)(b_70[32:]) } sz_38: { b := b_38[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_6 = (*[6]byte)(b_38[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_6 = (*[6]byte)(b_38[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_6: h += n @@ -2155,59 +3666,117 @@ sz_6: sz_101: { b := b_101[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_69 = (*[69]byte)(b_101[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_69 = (*[69]byte)(b_101[32:]) } sz_69: { b := b_69[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_37 = (*[37]byte)(b_69[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_37 = (*[37]byte)(b_69[32:]) } sz_37: { b := b_37[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_5 = (*[5]byte)(b_37[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_5 = (*[5]byte)(b_37[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_5: h += n @@ -2216,59 +3785,117 @@ sz_5: sz_100: { b := b_100[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_68 = (*[68]byte)(b_100[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_68 = (*[68]byte)(b_100[32:]) } sz_68: { b := b_68[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_36 = (*[36]byte)(b_68[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_36 = (*[36]byte)(b_68[32:]) } sz_36: { b := b_36[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_4 = (*[4]byte)(b_36[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_4 = (*[4]byte)(b_36[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_4: h += n @@ -2277,59 +3904,117 @@ sz_4: sz_99: { b := b_99[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_67 = (*[67]byte)(b_99[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_67 = (*[67]byte)(b_99[32:]) } sz_67: { b := b_67[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_35 = (*[35]byte)(b_67[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_35 = (*[35]byte)(b_67[32:]) } sz_35: { b := b_35[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_3 = (*[3]byte)(b_35[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_3 = (*[3]byte)(b_35[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_3: h += n @@ -2338,59 +4023,117 @@ sz_3: sz_98: { b := b_98[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_66 = (*[66]byte)(b_98[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_66 = (*[66]byte)(b_98[32:]) } sz_66: { b := b_66[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_34 = (*[34]byte)(b_66[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_34 = (*[34]byte)(b_66[32:]) } sz_34: { b := b_34[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_2 = (*[2]byte)(b_34[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_2 = (*[2]byte)(b_34[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_2: h += n @@ -2399,59 +4142,117 @@ sz_2: sz_97: { b := b_97[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_65 = (*[65]byte)(b_97[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_65 = (*[65]byte)(b_97[32:]) } sz_65: { b := b_65[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_33 = (*[33]byte)(b_65[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_33 = (*[33]byte)(b_65[32:]) } sz_33: { b := b_33[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_1 = (*[1]byte)(b_33[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_1 = (*[1]byte)(b_33[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } sz_1: h += n @@ -2460,59 +4261,117 @@ sz_1: sz_96: { b := b_96[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_64 = (*[64]byte)(b_96[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_64 = (*[64]byte)(b_96[32:]) } sz_64: { b := b_64[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_32 = (*[32]byte)(b_64[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_32 = (*[32]byte)(b_64[32:]) } sz_32: { b := b_32[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. + var load uint64 + load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v1 = round(v1, load) + v1 += load * prime2 + v1 = bits.RotateLeft64(v1, 31) + v1 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v2 = round(v2, load) + v2 += load * prime2 + v2 = bits.RotateLeft64(v2, 31) + v2 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. b = b[8:] - v3 = round(v3, load) + v3 += load * prime2 + v3 = bits.RotateLeft64(v3, 31) + v3 *= prime1 load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - v4 = round(v4, load) - b_0 = (*[0]byte)(b_32[32:]) + b = b[8:] + v4 += load * prime2 + v4 = bits.RotateLeft64(v4, 31) + v4 *= prime1 +b_0 = (*[0]byte)(b_32[32:]) } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) + h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) + { + var temp uint64 + temp += v1 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v2 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v3 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } + { + var temp uint64 + temp += v4 * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 + h ^= temp + h = h*prime1 + prime4 + } h += n goto sz_0l @@ -2522,8 +4381,12 @@ sz_31l: { b := b_31[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_23 = (*[23]byte)(b_31[8:]) } @@ -2531,8 +4394,12 @@ sz_23l: { b := b_23[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_15 = (*[15]byte)(b_23[8:]) } @@ -2540,8 +4407,12 @@ sz_15l: { b := b_15[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_7 = (*[7]byte)(b_15[8:]) } @@ -2551,8 +4422,12 @@ sz_30l: { b := b_30[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_22 = (*[22]byte)(b_30[8:]) } @@ -2560,8 +4435,12 @@ sz_22l: { b := b_22[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_14 = (*[14]byte)(b_22[8:]) } @@ -2569,8 +4448,12 @@ sz_14l: { b := b_14[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_6 = (*[6]byte)(b_14[8:]) } @@ -2580,8 +4463,12 @@ sz_29l: { b := b_29[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_21 = (*[21]byte)(b_29[8:]) } @@ -2589,8 +4476,12 @@ sz_21l: { b := b_21[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_13 = (*[13]byte)(b_21[8:]) } @@ -2598,8 +4489,12 @@ sz_13l: { b := b_13[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_5 = (*[5]byte)(b_13[8:]) } @@ -2609,8 +4504,12 @@ sz_28l: { b := b_28[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_20 = (*[20]byte)(b_28[8:]) } @@ -2618,8 +4517,12 @@ sz_20l: { b := b_20[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_12 = (*[12]byte)(b_20[8:]) } @@ -2627,8 +4530,12 @@ sz_12l: { b := b_12[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_4 = (*[4]byte)(b_12[8:]) } @@ -2638,8 +4545,12 @@ sz_27l: { b := b_27[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_19 = (*[19]byte)(b_27[8:]) } @@ -2647,8 +4558,12 @@ sz_19l: { b := b_19[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_11 = (*[11]byte)(b_19[8:]) } @@ -2656,8 +4571,12 @@ sz_11l: { b := b_11[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_3 = (*[3]byte)(b_11[8:]) } @@ -2667,8 +4586,12 @@ sz_26l: { b := b_26[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_18 = (*[18]byte)(b_26[8:]) } @@ -2676,8 +4599,12 @@ sz_18l: { b := b_18[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_10 = (*[10]byte)(b_18[8:]) } @@ -2685,8 +4612,12 @@ sz_10l: { b := b_10[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_2 = (*[2]byte)(b_10[8:]) } @@ -2696,8 +4627,12 @@ sz_25l: { b := b_25[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_17 = (*[17]byte)(b_25[8:]) } @@ -2705,8 +4640,12 @@ sz_17l: { b := b_17[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_9 = (*[9]byte)(b_17[8:]) } @@ -2714,8 +4653,12 @@ sz_9l: { b := b_9[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_1 = (*[1]byte)(b_9[8:]) } @@ -2725,8 +4668,12 @@ sz_24l: { b := b_24[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_16 = (*[16]byte)(b_24[8:]) } @@ -2734,8 +4681,12 @@ sz_16l: { b := b_16[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_8 = (*[8]byte)(b_16[8:]) } @@ -2743,8 +4694,12 @@ sz_8l: { b := b_8[:] load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - h ^= round(0, load) - h = rol27(h)*prime1 + prime4 + var temp uint64 + temp += load * prime2 + temp = bits.RotateLeft64(temp, 31) + temp *= prime1 +h ^= temp + h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_0 = (*[0]byte)(b_8[8:]) } @@ -2756,7 +4711,7 @@ sz_7l: b := b_7[:] load := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 // Work around for go.dev/issue/68081. h ^= uint64(load) * prime1 - h = rol23(h)*prime2 + prime3 + h = bits.RotateLeft64(h, 23)*prime2 + prime3 b_3 = (*[3]byte)(b_7[4:]) goto sz_3l } @@ -2766,7 +4721,7 @@ sz_6l: b := b_6[:] load := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 // Work around for go.dev/issue/68081. h ^= uint64(load) * prime1 - h = rol23(h)*prime2 + prime3 + h = bits.RotateLeft64(h, 23)*prime2 + prime3 b_2 = (*[2]byte)(b_6[4:]) goto sz_2l } @@ -2776,7 +4731,7 @@ sz_5l: b := b_5[:] load := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 // Work around for go.dev/issue/68081. h ^= uint64(load) * prime1 - h = rol23(h)*prime2 + prime3 + h = bits.RotateLeft64(h, 23)*prime2 + prime3 b_1 = (*[1]byte)(b_5[4:]) goto sz_1l } @@ -2786,7 +4741,7 @@ sz_4l: b := b_4[:] load := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 // Work around for go.dev/issue/68081. h ^= uint64(load) * prime1 - h = rol23(h)*prime2 + prime3 + h = bits.RotateLeft64(h, 23)*prime2 + prime3 b_0 = (*[0]byte)(b_4[4:]) goto sz_0l } @@ -2794,17 +4749,17 @@ sz_4l: // This is the 1 bytes trailing slide. sz_3l: h ^= uint64(b_3[0]) * prime5 - h = rol11(h) * prime1 + h = bits.RotateLeft64(h, 11) * prime1 b_2 = (*[2]byte)(b_3[1:]) sz_2l: h ^= uint64(b_2[0]) * prime5 - h = rol11(h) * prime1 + h = bits.RotateLeft64(h, 11) * prime1 b_1 = (*[1]byte)(b_2[1:]) sz_1l: h ^= uint64(b_1[0]) * prime5 - h = rol11(h) * prime1 + h = bits.RotateLeft64(h, 11) * prime1 b_0 = (*[0]byte)(b_1[1:]) // Finally the terminator. From 5103d35c06d6edef6dcc3725561254a030f821b7 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Thu, 20 Jun 2024 10:01:55 +0200 Subject: [PATCH 14/16] fix slidegen so it outputs go fmted code --- gen/slide.go | 12 +- xxhash_slide.go | 514 ++++++++++++++++++++++++------------------------ 2 files changed, 261 insertions(+), 265 deletions(-) diff --git a/gen/slide.go b/gen/slide.go index 84384b7..8797410 100644 --- a/gen/slide.go +++ b/gen/slide.go @@ -55,14 +55,12 @@ func slide(b []byte) uint64 { // The go compiler has multiple oversight in the propragation of proofs through Phi nodes. Using array pointers is a very unsubtle hint and compiles to nothing. // Because we assume the compiler has some low level SSA passes this is otherwise free. - var ( `, sumSlideSize, sumSlideSize) for i := 0; i <= sumSlideSize; i++ { - fmt.Fprintf(w, "\t\tb_%d *[%d]byte\n", i, i) + fmt.Fprintf(w, "\tvar b_%d *[%d]byte\n", i, i) } - w.WriteString(` ) - + w.WriteString(` // Jump table to various positions in the slide, this setups proofs for bounds checks. // From then on it need to make sure to maintain constance in the length of b. switch len(b) { @@ -104,7 +102,7 @@ func slide(b []byte) uint64 { `, load64) genRound(w, 2, fmt.Sprintf("v%d", r), "load") } - fmt.Fprintf(w, `b_%d = (*[%d]byte)(b_%d[32:]) + fmt.Fprintf(w, ` b_%d = (*[%d]byte)(b_%d[32:]) } `, i-32, i-32, i) @@ -138,14 +136,14 @@ func slide(b []byte) uint64 { var temp uint64 `, i, i, load64) genRound(w, 2, "temp", "load") - fmt.Fprintf(w, `h ^= temp + fmt.Fprintf(w, ` h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_%d = (*[%d]byte)(b_%d[8:]) } `, i-8, i-8, i) } - fmt.Fprintf(w, `goto sz_%dl + fmt.Fprintf(w, ` goto sz_%dl `, i) } diff --git a/xxhash_slide.go b/xxhash_slide.go index 64b962c..c4a76a2 100644 --- a/xxhash_slide.go +++ b/xxhash_slide.go @@ -40,136 +40,134 @@ func slide(b []byte) uint64 { // The go compiler has multiple oversight in the propragation of proofs through Phi nodes. Using array pointers is a very unsubtle hint and compiles to nothing. // Because we assume the compiler has some low level SSA passes this is otherwise free. - var ( - b_0 *[0]byte - b_1 *[1]byte - b_2 *[2]byte - b_3 *[3]byte - b_4 *[4]byte - b_5 *[5]byte - b_6 *[6]byte - b_7 *[7]byte - b_8 *[8]byte - b_9 *[9]byte - b_10 *[10]byte - b_11 *[11]byte - b_12 *[12]byte - b_13 *[13]byte - b_14 *[14]byte - b_15 *[15]byte - b_16 *[16]byte - b_17 *[17]byte - b_18 *[18]byte - b_19 *[19]byte - b_20 *[20]byte - b_21 *[21]byte - b_22 *[22]byte - b_23 *[23]byte - b_24 *[24]byte - b_25 *[25]byte - b_26 *[26]byte - b_27 *[27]byte - b_28 *[28]byte - b_29 *[29]byte - b_30 *[30]byte - b_31 *[31]byte - b_32 *[32]byte - b_33 *[33]byte - b_34 *[34]byte - b_35 *[35]byte - b_36 *[36]byte - b_37 *[37]byte - b_38 *[38]byte - b_39 *[39]byte - b_40 *[40]byte - b_41 *[41]byte - b_42 *[42]byte - b_43 *[43]byte - b_44 *[44]byte - b_45 *[45]byte - b_46 *[46]byte - b_47 *[47]byte - b_48 *[48]byte - b_49 *[49]byte - b_50 *[50]byte - b_51 *[51]byte - b_52 *[52]byte - b_53 *[53]byte - b_54 *[54]byte - b_55 *[55]byte - b_56 *[56]byte - b_57 *[57]byte - b_58 *[58]byte - b_59 *[59]byte - b_60 *[60]byte - b_61 *[61]byte - b_62 *[62]byte - b_63 *[63]byte - b_64 *[64]byte - b_65 *[65]byte - b_66 *[66]byte - b_67 *[67]byte - b_68 *[68]byte - b_69 *[69]byte - b_70 *[70]byte - b_71 *[71]byte - b_72 *[72]byte - b_73 *[73]byte - b_74 *[74]byte - b_75 *[75]byte - b_76 *[76]byte - b_77 *[77]byte - b_78 *[78]byte - b_79 *[79]byte - b_80 *[80]byte - b_81 *[81]byte - b_82 *[82]byte - b_83 *[83]byte - b_84 *[84]byte - b_85 *[85]byte - b_86 *[86]byte - b_87 *[87]byte - b_88 *[88]byte - b_89 *[89]byte - b_90 *[90]byte - b_91 *[91]byte - b_92 *[92]byte - b_93 *[93]byte - b_94 *[94]byte - b_95 *[95]byte - b_96 *[96]byte - b_97 *[97]byte - b_98 *[98]byte - b_99 *[99]byte - b_100 *[100]byte - b_101 *[101]byte - b_102 *[102]byte - b_103 *[103]byte - b_104 *[104]byte - b_105 *[105]byte - b_106 *[106]byte - b_107 *[107]byte - b_108 *[108]byte - b_109 *[109]byte - b_110 *[110]byte - b_111 *[111]byte - b_112 *[112]byte - b_113 *[113]byte - b_114 *[114]byte - b_115 *[115]byte - b_116 *[116]byte - b_117 *[117]byte - b_118 *[118]byte - b_119 *[119]byte - b_120 *[120]byte - b_121 *[121]byte - b_122 *[122]byte - b_123 *[123]byte - b_124 *[124]byte - b_125 *[125]byte - b_126 *[126]byte - b_127 *[127]byte - ) + var b_0 *[0]byte + var b_1 *[1]byte + var b_2 *[2]byte + var b_3 *[3]byte + var b_4 *[4]byte + var b_5 *[5]byte + var b_6 *[6]byte + var b_7 *[7]byte + var b_8 *[8]byte + var b_9 *[9]byte + var b_10 *[10]byte + var b_11 *[11]byte + var b_12 *[12]byte + var b_13 *[13]byte + var b_14 *[14]byte + var b_15 *[15]byte + var b_16 *[16]byte + var b_17 *[17]byte + var b_18 *[18]byte + var b_19 *[19]byte + var b_20 *[20]byte + var b_21 *[21]byte + var b_22 *[22]byte + var b_23 *[23]byte + var b_24 *[24]byte + var b_25 *[25]byte + var b_26 *[26]byte + var b_27 *[27]byte + var b_28 *[28]byte + var b_29 *[29]byte + var b_30 *[30]byte + var b_31 *[31]byte + var b_32 *[32]byte + var b_33 *[33]byte + var b_34 *[34]byte + var b_35 *[35]byte + var b_36 *[36]byte + var b_37 *[37]byte + var b_38 *[38]byte + var b_39 *[39]byte + var b_40 *[40]byte + var b_41 *[41]byte + var b_42 *[42]byte + var b_43 *[43]byte + var b_44 *[44]byte + var b_45 *[45]byte + var b_46 *[46]byte + var b_47 *[47]byte + var b_48 *[48]byte + var b_49 *[49]byte + var b_50 *[50]byte + var b_51 *[51]byte + var b_52 *[52]byte + var b_53 *[53]byte + var b_54 *[54]byte + var b_55 *[55]byte + var b_56 *[56]byte + var b_57 *[57]byte + var b_58 *[58]byte + var b_59 *[59]byte + var b_60 *[60]byte + var b_61 *[61]byte + var b_62 *[62]byte + var b_63 *[63]byte + var b_64 *[64]byte + var b_65 *[65]byte + var b_66 *[66]byte + var b_67 *[67]byte + var b_68 *[68]byte + var b_69 *[69]byte + var b_70 *[70]byte + var b_71 *[71]byte + var b_72 *[72]byte + var b_73 *[73]byte + var b_74 *[74]byte + var b_75 *[75]byte + var b_76 *[76]byte + var b_77 *[77]byte + var b_78 *[78]byte + var b_79 *[79]byte + var b_80 *[80]byte + var b_81 *[81]byte + var b_82 *[82]byte + var b_83 *[83]byte + var b_84 *[84]byte + var b_85 *[85]byte + var b_86 *[86]byte + var b_87 *[87]byte + var b_88 *[88]byte + var b_89 *[89]byte + var b_90 *[90]byte + var b_91 *[91]byte + var b_92 *[92]byte + var b_93 *[93]byte + var b_94 *[94]byte + var b_95 *[95]byte + var b_96 *[96]byte + var b_97 *[97]byte + var b_98 *[98]byte + var b_99 *[99]byte + var b_100 *[100]byte + var b_101 *[101]byte + var b_102 *[102]byte + var b_103 *[103]byte + var b_104 *[104]byte + var b_105 *[105]byte + var b_106 *[106]byte + var b_107 *[107]byte + var b_108 *[108]byte + var b_109 *[109]byte + var b_110 *[110]byte + var b_111 *[111]byte + var b_112 *[112]byte + var b_113 *[113]byte + var b_114 *[114]byte + var b_115 *[115]byte + var b_116 *[116]byte + var b_117 *[117]byte + var b_118 *[118]byte + var b_119 *[119]byte + var b_120 *[120]byte + var b_121 *[121]byte + var b_122 *[122]byte + var b_123 *[123]byte + var b_124 *[124]byte + var b_125 *[125]byte + var b_126 *[126]byte + var b_127 *[127]byte // Jump table to various positions in the slide, this setups proofs for bounds checks. // From then on it need to make sure to maintain constance in the length of b. @@ -593,7 +591,7 @@ sz_127: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_95 = (*[95]byte)(b_127[32:]) + b_95 = (*[95]byte)(b_127[32:]) } sz_95: @@ -620,7 +618,7 @@ sz_95: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_63 = (*[63]byte)(b_95[32:]) + b_63 = (*[63]byte)(b_95[32:]) } sz_63: @@ -647,7 +645,7 @@ sz_63: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_31 = (*[31]byte)(b_63[32:]) + b_31 = (*[31]byte)(b_63[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -712,7 +710,7 @@ sz_126: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_94 = (*[94]byte)(b_126[32:]) + b_94 = (*[94]byte)(b_126[32:]) } sz_94: @@ -739,7 +737,7 @@ sz_94: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_62 = (*[62]byte)(b_94[32:]) + b_62 = (*[62]byte)(b_94[32:]) } sz_62: @@ -766,7 +764,7 @@ sz_62: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_30 = (*[30]byte)(b_62[32:]) + b_30 = (*[30]byte)(b_62[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -831,7 +829,7 @@ sz_125: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_93 = (*[93]byte)(b_125[32:]) + b_93 = (*[93]byte)(b_125[32:]) } sz_93: @@ -858,7 +856,7 @@ sz_93: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_61 = (*[61]byte)(b_93[32:]) + b_61 = (*[61]byte)(b_93[32:]) } sz_61: @@ -885,7 +883,7 @@ sz_61: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_29 = (*[29]byte)(b_61[32:]) + b_29 = (*[29]byte)(b_61[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -950,7 +948,7 @@ sz_124: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_92 = (*[92]byte)(b_124[32:]) + b_92 = (*[92]byte)(b_124[32:]) } sz_92: @@ -977,7 +975,7 @@ sz_92: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_60 = (*[60]byte)(b_92[32:]) + b_60 = (*[60]byte)(b_92[32:]) } sz_60: @@ -1004,7 +1002,7 @@ sz_60: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_28 = (*[28]byte)(b_60[32:]) + b_28 = (*[28]byte)(b_60[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -1069,7 +1067,7 @@ sz_123: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_91 = (*[91]byte)(b_123[32:]) + b_91 = (*[91]byte)(b_123[32:]) } sz_91: @@ -1096,7 +1094,7 @@ sz_91: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_59 = (*[59]byte)(b_91[32:]) + b_59 = (*[59]byte)(b_91[32:]) } sz_59: @@ -1123,7 +1121,7 @@ sz_59: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_27 = (*[27]byte)(b_59[32:]) + b_27 = (*[27]byte)(b_59[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -1188,7 +1186,7 @@ sz_122: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_90 = (*[90]byte)(b_122[32:]) + b_90 = (*[90]byte)(b_122[32:]) } sz_90: @@ -1215,7 +1213,7 @@ sz_90: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_58 = (*[58]byte)(b_90[32:]) + b_58 = (*[58]byte)(b_90[32:]) } sz_58: @@ -1242,7 +1240,7 @@ sz_58: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_26 = (*[26]byte)(b_58[32:]) + b_26 = (*[26]byte)(b_58[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -1307,7 +1305,7 @@ sz_121: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_89 = (*[89]byte)(b_121[32:]) + b_89 = (*[89]byte)(b_121[32:]) } sz_89: @@ -1334,7 +1332,7 @@ sz_89: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_57 = (*[57]byte)(b_89[32:]) + b_57 = (*[57]byte)(b_89[32:]) } sz_57: @@ -1361,7 +1359,7 @@ sz_57: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_25 = (*[25]byte)(b_57[32:]) + b_25 = (*[25]byte)(b_57[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -1426,7 +1424,7 @@ sz_120: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_88 = (*[88]byte)(b_120[32:]) + b_88 = (*[88]byte)(b_120[32:]) } sz_88: @@ -1453,7 +1451,7 @@ sz_88: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_56 = (*[56]byte)(b_88[32:]) + b_56 = (*[56]byte)(b_88[32:]) } sz_56: @@ -1480,7 +1478,7 @@ sz_56: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_24 = (*[24]byte)(b_56[32:]) + b_24 = (*[24]byte)(b_56[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -1545,7 +1543,7 @@ sz_119: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_87 = (*[87]byte)(b_119[32:]) + b_87 = (*[87]byte)(b_119[32:]) } sz_87: @@ -1572,7 +1570,7 @@ sz_87: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_55 = (*[55]byte)(b_87[32:]) + b_55 = (*[55]byte)(b_87[32:]) } sz_55: @@ -1599,7 +1597,7 @@ sz_55: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_23 = (*[23]byte)(b_55[32:]) + b_23 = (*[23]byte)(b_55[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -1664,7 +1662,7 @@ sz_118: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_86 = (*[86]byte)(b_118[32:]) + b_86 = (*[86]byte)(b_118[32:]) } sz_86: @@ -1691,7 +1689,7 @@ sz_86: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_54 = (*[54]byte)(b_86[32:]) + b_54 = (*[54]byte)(b_86[32:]) } sz_54: @@ -1718,7 +1716,7 @@ sz_54: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_22 = (*[22]byte)(b_54[32:]) + b_22 = (*[22]byte)(b_54[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -1783,7 +1781,7 @@ sz_117: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_85 = (*[85]byte)(b_117[32:]) + b_85 = (*[85]byte)(b_117[32:]) } sz_85: @@ -1810,7 +1808,7 @@ sz_85: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_53 = (*[53]byte)(b_85[32:]) + b_53 = (*[53]byte)(b_85[32:]) } sz_53: @@ -1837,7 +1835,7 @@ sz_53: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_21 = (*[21]byte)(b_53[32:]) + b_21 = (*[21]byte)(b_53[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -1902,7 +1900,7 @@ sz_116: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_84 = (*[84]byte)(b_116[32:]) + b_84 = (*[84]byte)(b_116[32:]) } sz_84: @@ -1929,7 +1927,7 @@ sz_84: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_52 = (*[52]byte)(b_84[32:]) + b_52 = (*[52]byte)(b_84[32:]) } sz_52: @@ -1956,7 +1954,7 @@ sz_52: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_20 = (*[20]byte)(b_52[32:]) + b_20 = (*[20]byte)(b_52[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -2021,7 +2019,7 @@ sz_115: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_83 = (*[83]byte)(b_115[32:]) + b_83 = (*[83]byte)(b_115[32:]) } sz_83: @@ -2048,7 +2046,7 @@ sz_83: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_51 = (*[51]byte)(b_83[32:]) + b_51 = (*[51]byte)(b_83[32:]) } sz_51: @@ -2075,7 +2073,7 @@ sz_51: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_19 = (*[19]byte)(b_51[32:]) + b_19 = (*[19]byte)(b_51[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -2140,7 +2138,7 @@ sz_114: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_82 = (*[82]byte)(b_114[32:]) + b_82 = (*[82]byte)(b_114[32:]) } sz_82: @@ -2167,7 +2165,7 @@ sz_82: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_50 = (*[50]byte)(b_82[32:]) + b_50 = (*[50]byte)(b_82[32:]) } sz_50: @@ -2194,7 +2192,7 @@ sz_50: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_18 = (*[18]byte)(b_50[32:]) + b_18 = (*[18]byte)(b_50[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -2259,7 +2257,7 @@ sz_113: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_81 = (*[81]byte)(b_113[32:]) + b_81 = (*[81]byte)(b_113[32:]) } sz_81: @@ -2286,7 +2284,7 @@ sz_81: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_49 = (*[49]byte)(b_81[32:]) + b_49 = (*[49]byte)(b_81[32:]) } sz_49: @@ -2313,7 +2311,7 @@ sz_49: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_17 = (*[17]byte)(b_49[32:]) + b_17 = (*[17]byte)(b_49[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -2378,7 +2376,7 @@ sz_112: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_80 = (*[80]byte)(b_112[32:]) + b_80 = (*[80]byte)(b_112[32:]) } sz_80: @@ -2405,7 +2403,7 @@ sz_80: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_48 = (*[48]byte)(b_80[32:]) + b_48 = (*[48]byte)(b_80[32:]) } sz_48: @@ -2432,7 +2430,7 @@ sz_48: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_16 = (*[16]byte)(b_48[32:]) + b_16 = (*[16]byte)(b_48[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -2497,7 +2495,7 @@ sz_111: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_79 = (*[79]byte)(b_111[32:]) + b_79 = (*[79]byte)(b_111[32:]) } sz_79: @@ -2524,7 +2522,7 @@ sz_79: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_47 = (*[47]byte)(b_79[32:]) + b_47 = (*[47]byte)(b_79[32:]) } sz_47: @@ -2551,7 +2549,7 @@ sz_47: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_15 = (*[15]byte)(b_47[32:]) + b_15 = (*[15]byte)(b_47[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -2616,7 +2614,7 @@ sz_110: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_78 = (*[78]byte)(b_110[32:]) + b_78 = (*[78]byte)(b_110[32:]) } sz_78: @@ -2643,7 +2641,7 @@ sz_78: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_46 = (*[46]byte)(b_78[32:]) + b_46 = (*[46]byte)(b_78[32:]) } sz_46: @@ -2670,7 +2668,7 @@ sz_46: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_14 = (*[14]byte)(b_46[32:]) + b_14 = (*[14]byte)(b_46[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -2735,7 +2733,7 @@ sz_109: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_77 = (*[77]byte)(b_109[32:]) + b_77 = (*[77]byte)(b_109[32:]) } sz_77: @@ -2762,7 +2760,7 @@ sz_77: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_45 = (*[45]byte)(b_77[32:]) + b_45 = (*[45]byte)(b_77[32:]) } sz_45: @@ -2789,7 +2787,7 @@ sz_45: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_13 = (*[13]byte)(b_45[32:]) + b_13 = (*[13]byte)(b_45[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -2854,7 +2852,7 @@ sz_108: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_76 = (*[76]byte)(b_108[32:]) + b_76 = (*[76]byte)(b_108[32:]) } sz_76: @@ -2881,7 +2879,7 @@ sz_76: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_44 = (*[44]byte)(b_76[32:]) + b_44 = (*[44]byte)(b_76[32:]) } sz_44: @@ -2908,7 +2906,7 @@ sz_44: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_12 = (*[12]byte)(b_44[32:]) + b_12 = (*[12]byte)(b_44[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -2973,7 +2971,7 @@ sz_107: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_75 = (*[75]byte)(b_107[32:]) + b_75 = (*[75]byte)(b_107[32:]) } sz_75: @@ -3000,7 +2998,7 @@ sz_75: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_43 = (*[43]byte)(b_75[32:]) + b_43 = (*[43]byte)(b_75[32:]) } sz_43: @@ -3027,7 +3025,7 @@ sz_43: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_11 = (*[11]byte)(b_43[32:]) + b_11 = (*[11]byte)(b_43[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -3092,7 +3090,7 @@ sz_106: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_74 = (*[74]byte)(b_106[32:]) + b_74 = (*[74]byte)(b_106[32:]) } sz_74: @@ -3119,7 +3117,7 @@ sz_74: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_42 = (*[42]byte)(b_74[32:]) + b_42 = (*[42]byte)(b_74[32:]) } sz_42: @@ -3146,7 +3144,7 @@ sz_42: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_10 = (*[10]byte)(b_42[32:]) + b_10 = (*[10]byte)(b_42[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -3211,7 +3209,7 @@ sz_105: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_73 = (*[73]byte)(b_105[32:]) + b_73 = (*[73]byte)(b_105[32:]) } sz_73: @@ -3238,7 +3236,7 @@ sz_73: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_41 = (*[41]byte)(b_73[32:]) + b_41 = (*[41]byte)(b_73[32:]) } sz_41: @@ -3265,7 +3263,7 @@ sz_41: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_9 = (*[9]byte)(b_41[32:]) + b_9 = (*[9]byte)(b_41[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -3330,7 +3328,7 @@ sz_104: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_72 = (*[72]byte)(b_104[32:]) + b_72 = (*[72]byte)(b_104[32:]) } sz_72: @@ -3357,7 +3355,7 @@ sz_72: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_40 = (*[40]byte)(b_72[32:]) + b_40 = (*[40]byte)(b_72[32:]) } sz_40: @@ -3384,7 +3382,7 @@ sz_40: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_8 = (*[8]byte)(b_40[32:]) + b_8 = (*[8]byte)(b_40[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -3449,7 +3447,7 @@ sz_103: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_71 = (*[71]byte)(b_103[32:]) + b_71 = (*[71]byte)(b_103[32:]) } sz_71: @@ -3476,7 +3474,7 @@ sz_71: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_39 = (*[39]byte)(b_71[32:]) + b_39 = (*[39]byte)(b_71[32:]) } sz_39: @@ -3503,7 +3501,7 @@ sz_39: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_7 = (*[7]byte)(b_39[32:]) + b_7 = (*[7]byte)(b_39[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -3568,7 +3566,7 @@ sz_102: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_70 = (*[70]byte)(b_102[32:]) + b_70 = (*[70]byte)(b_102[32:]) } sz_70: @@ -3595,7 +3593,7 @@ sz_70: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_38 = (*[38]byte)(b_70[32:]) + b_38 = (*[38]byte)(b_70[32:]) } sz_38: @@ -3622,7 +3620,7 @@ sz_38: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_6 = (*[6]byte)(b_38[32:]) + b_6 = (*[6]byte)(b_38[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -3687,7 +3685,7 @@ sz_101: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_69 = (*[69]byte)(b_101[32:]) + b_69 = (*[69]byte)(b_101[32:]) } sz_69: @@ -3714,7 +3712,7 @@ sz_69: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_37 = (*[37]byte)(b_69[32:]) + b_37 = (*[37]byte)(b_69[32:]) } sz_37: @@ -3741,7 +3739,7 @@ sz_37: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_5 = (*[5]byte)(b_37[32:]) + b_5 = (*[5]byte)(b_37[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -3806,7 +3804,7 @@ sz_100: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_68 = (*[68]byte)(b_100[32:]) + b_68 = (*[68]byte)(b_100[32:]) } sz_68: @@ -3833,7 +3831,7 @@ sz_68: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_36 = (*[36]byte)(b_68[32:]) + b_36 = (*[36]byte)(b_68[32:]) } sz_36: @@ -3860,7 +3858,7 @@ sz_36: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_4 = (*[4]byte)(b_36[32:]) + b_4 = (*[4]byte)(b_36[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -3925,7 +3923,7 @@ sz_99: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_67 = (*[67]byte)(b_99[32:]) + b_67 = (*[67]byte)(b_99[32:]) } sz_67: @@ -3952,7 +3950,7 @@ sz_67: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_35 = (*[35]byte)(b_67[32:]) + b_35 = (*[35]byte)(b_67[32:]) } sz_35: @@ -3979,7 +3977,7 @@ sz_35: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_3 = (*[3]byte)(b_35[32:]) + b_3 = (*[3]byte)(b_35[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -4044,7 +4042,7 @@ sz_98: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_66 = (*[66]byte)(b_98[32:]) + b_66 = (*[66]byte)(b_98[32:]) } sz_66: @@ -4071,7 +4069,7 @@ sz_66: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_34 = (*[34]byte)(b_66[32:]) + b_34 = (*[34]byte)(b_66[32:]) } sz_34: @@ -4098,7 +4096,7 @@ sz_34: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_2 = (*[2]byte)(b_34[32:]) + b_2 = (*[2]byte)(b_34[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -4163,7 +4161,7 @@ sz_97: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_65 = (*[65]byte)(b_97[32:]) + b_65 = (*[65]byte)(b_97[32:]) } sz_65: @@ -4190,7 +4188,7 @@ sz_65: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_33 = (*[33]byte)(b_65[32:]) + b_33 = (*[33]byte)(b_65[32:]) } sz_33: @@ -4217,7 +4215,7 @@ sz_33: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_1 = (*[1]byte)(b_33[32:]) + b_1 = (*[1]byte)(b_33[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -4282,7 +4280,7 @@ sz_96: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_64 = (*[64]byte)(b_96[32:]) + b_64 = (*[64]byte)(b_96[32:]) } sz_64: @@ -4309,7 +4307,7 @@ sz_64: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_32 = (*[32]byte)(b_64[32:]) + b_32 = (*[32]byte)(b_64[32:]) } sz_32: @@ -4336,7 +4334,7 @@ sz_32: v4 += load * prime2 v4 = bits.RotateLeft64(v4, 31) v4 *= prime1 -b_0 = (*[0]byte)(b_32[32:]) + b_0 = (*[0]byte)(b_32[32:]) } h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) @@ -4385,7 +4383,7 @@ sz_31l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_23 = (*[23]byte)(b_31[8:]) } @@ -4398,7 +4396,7 @@ sz_23l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_15 = (*[15]byte)(b_23[8:]) } @@ -4411,12 +4409,12 @@ sz_15l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_7 = (*[7]byte)(b_15[8:]) } -goto sz_7l + goto sz_7l sz_30l: { @@ -4426,7 +4424,7 @@ sz_30l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_22 = (*[22]byte)(b_30[8:]) } @@ -4439,7 +4437,7 @@ sz_22l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_14 = (*[14]byte)(b_22[8:]) } @@ -4452,12 +4450,12 @@ sz_14l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_6 = (*[6]byte)(b_14[8:]) } -goto sz_6l + goto sz_6l sz_29l: { @@ -4467,7 +4465,7 @@ sz_29l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_21 = (*[21]byte)(b_29[8:]) } @@ -4480,7 +4478,7 @@ sz_21l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_13 = (*[13]byte)(b_21[8:]) } @@ -4493,12 +4491,12 @@ sz_13l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_5 = (*[5]byte)(b_13[8:]) } -goto sz_5l + goto sz_5l sz_28l: { @@ -4508,7 +4506,7 @@ sz_28l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_20 = (*[20]byte)(b_28[8:]) } @@ -4521,7 +4519,7 @@ sz_20l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_12 = (*[12]byte)(b_20[8:]) } @@ -4534,12 +4532,12 @@ sz_12l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_4 = (*[4]byte)(b_12[8:]) } -goto sz_4l + goto sz_4l sz_27l: { @@ -4549,7 +4547,7 @@ sz_27l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_19 = (*[19]byte)(b_27[8:]) } @@ -4562,7 +4560,7 @@ sz_19l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_11 = (*[11]byte)(b_19[8:]) } @@ -4575,12 +4573,12 @@ sz_11l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_3 = (*[3]byte)(b_11[8:]) } -goto sz_3l + goto sz_3l sz_26l: { @@ -4590,7 +4588,7 @@ sz_26l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_18 = (*[18]byte)(b_26[8:]) } @@ -4603,7 +4601,7 @@ sz_18l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_10 = (*[10]byte)(b_18[8:]) } @@ -4616,12 +4614,12 @@ sz_10l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_2 = (*[2]byte)(b_10[8:]) } -goto sz_2l + goto sz_2l sz_25l: { @@ -4631,7 +4629,7 @@ sz_25l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_17 = (*[17]byte)(b_25[8:]) } @@ -4644,7 +4642,7 @@ sz_17l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_9 = (*[9]byte)(b_17[8:]) } @@ -4657,12 +4655,12 @@ sz_9l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_1 = (*[1]byte)(b_9[8:]) } -goto sz_1l + goto sz_1l sz_24l: { @@ -4672,7 +4670,7 @@ sz_24l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_16 = (*[16]byte)(b_24[8:]) } @@ -4685,7 +4683,7 @@ sz_16l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_8 = (*[8]byte)(b_16[8:]) } @@ -4698,12 +4696,12 @@ sz_8l: temp += load * prime2 temp = bits.RotateLeft64(temp, 31) temp *= prime1 -h ^= temp + h ^= temp h = bits.RotateLeft64(h, 27)*prime1 + prime4 b_0 = (*[0]byte)(b_8[8:]) } -goto sz_0l + goto sz_0l // Theses are the 4 bytes trailing slides. sz_7l: From 712cdadbec4759ffa9e51aef8f9d2224bf046bc0 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Thu, 20 Jun 2024 15:19:47 +0200 Subject: [PATCH 15/16] remove slide and handle jump in avx512 This removes the extra overhead and is cycle for cycle tied with pre-avx512 decision on non avx512. The PCALIGN on avx512 improves the performance from 28.5GiB/s to 30GiB/s on 4K, and 25GiB/s to 28GiB/s on 10M. This also removes avo because it were running in my legs as I couldn't get it to jump to an other function and cespare emited reservation to using it. --- gen/avx512.go | 248 --- gen/go.mod | 13 - gen/go.sum | 10 - gen/main.go | 13 - gen/slide.go | 234 -- xxhash_asm_amd64.go | 35 +- xxhash_avx512_amd64.s | 338 +-- xxhash_not_slide.go | 10 - xxhash_slide.go | 4774 ----------------------------------------- 9 files changed, 185 insertions(+), 5490 deletions(-) delete mode 100644 gen/avx512.go delete mode 100644 gen/go.mod delete mode 100644 gen/go.sum delete mode 100644 gen/main.go delete mode 100644 gen/slide.go delete mode 100644 xxhash_not_slide.go delete mode 100644 xxhash_slide.go diff --git a/gen/avx512.go b/gen/avx512.go deleted file mode 100644 index 4bb9f00..0000000 --- a/gen/avx512.go +++ /dev/null @@ -1,248 +0,0 @@ -package main - -import ( - "github.com/cespare/xxhash/v2" - . "github.com/mmcloughlin/avo/build" - . "github.com/mmcloughlin/avo/operand" - "github.com/mmcloughlin/avo/reg" -) - -const ( - prime1 uint64 = 11400714785074694791 - prime2 uint64 = 14029467366897019727 - prime3 uint64 = 1609587929392839161 - prime4 uint64 = 9650029242287828579 - prime5 uint64 = 2870177450012600261 -) - -func round0(v /*inout*/, p1, p2 reg.GPVirtual) { - IMULQ(p2, v) - ROLQ(Imm(31), v) - IMULQ(p1, v) -} - -func mergeRound(h /*inout*/, v /*in-destroy*/, p1, p2, p4 reg.GPVirtual) { - round0(v, p1, p2) - XORQ(v, h) - IMULQ(p1, h) - ADDQ(p4, h) -} - -func round(state /*inout*/, p, yprime1, yprime2 reg.Register) { - temp := YMM() - VMOVDQU(Mem{Base: p}, temp) - VPMULLQ(temp, yprime2, temp) - VPADDQ(temp, state, state) - VPROLQ(Imm(31), state, state) - VPMULLQ(state, yprime1, state) -} - -// blockLoop handles 32 bytes at a time in one YMM register. -// it assume n is 32 bytes or more. -// state represent v1, v2, v3, v4 as 4 × uint64. -func blockLoop(state /*inout*/, p /*inout*/, n, yprime1, yprime2 reg.Register) { - endp := GP64() - MOVL(U32(31), endp.As32()) - ANDNQ(n, endp, endp) - ADDQ(p, endp) - - Label("loop_32") - { - // main block loop - round(state, p, yprime1, yprime2) - ADDQ(Imm(32), p) - - CMPQ(p, endp) - JNE(LabelRef("loop_32")) - } -} - -func sum64() { - initStateAvx512 := GLOBL("·initWideAvx512", NOSPLIT|NOPTR) - prime1 := prime1 - DATA(0, U64(prime1+prime2)) - DATA(8, U64(prime2)) - DATA(16, U64(0)) - DATA(24, U64(-prime1)) - - TEXT("sum64Avx512", NOSPLIT|NOFRAME, "func(b []byte) uint64") - p := Load(Param("b").Base(), GP64()) - n := Load(Param("b").Len(), GP64()) - - p1, p2, p3, p4, p5 := GP64(), GP64(), GP64(), GP64(), GP64() - MOVQ(Imm(prime1), p1) - MOVQ(Imm(prime2), p2) - MOVQ(Imm(prime3), p3) - MOVQ(Imm(prime4), p4) - MOVQ(Imm(prime5), p5) - - h := GP64() - LEAQ(Mem{Base: p5, Index: n, Scale: 1}, h) - - TESTQ(n, n) - JZ(LabelRef("zero")) - CMPQ(n, Imm(3)) - JBE(LabelRef("loop_1")) - CMPQ(n, Imm(7)) - JBE(LabelRef("do_4")) - CMPQ(n, Imm(31)) - JBE(LabelRef("loop_8")) - - { - state := YMM() - VMOVDQU(initStateAvx512, state) - - yprime1, yprime2 := YMM(), YMM() - VPBROADCASTQ(p1, yprime1) - VPBROADCASTQ(p2, yprime2) - - blockLoop(state, p, n, yprime1, yprime2) - - // This interleave two things: extracting v1,2,3,4 from state and computing h. - v1, v2, v3, v4, temp := GP64(), GP64(), GP64(), GP64(), GP64() - VMOVQ(state.AsX(), v1) - MOVQ(v1, h) - ROLQ(Imm(1), h) - - VPEXTRQ(Imm(1), state.AsX(), v2) - MOVQ(v2, temp) - ROLQ(Imm(7), temp) - ADDQ(temp, h) - - VEXTRACTI128(Imm(1), state, state.AsX()) - VMOVQ(state.AsX(), v3) - MOVQ(v3, temp) - ROLQ(Imm(12), temp) - ADDQ(temp, h) - - VPEXTRQ(Imm(1), state.AsX(), v4) - VZEROUPPER() - MOVQ(v4, temp) - ROLQ(Imm(18), temp) - ADDQ(temp, h) - - // We could do round0 in SIMD if it's worth doing the two decompositions. - - mergeRound(h, v1, p1, p2, p4) - mergeRound(h, v2, p1, p2, p4) - mergeRound(h, v3, p1, p2, p4) - mergeRound(h, v4, p1, p2, p4) - - ADDQ(n, h) - ANDQ(Imm(31), n) - } - - // From this point on I didn't bothered writing SIMD code since this will handle at most 31 bytes. - - CMPQ(n, Imm(8)) - JB(LabelRef("skip_8")) - Label("loop_8") - { - temp := GP64() - MOVQ(Mem{Base: p}, temp) - ADDQ(Imm(8), p) - SUBQ(Imm(8), n) - round0(temp, p1, p2) - XORQ(temp, h) - ROLQ(Imm(27), h) - IMULQ(p1, h) - ADDQ(p4, h) - - CMPQ(n, Imm(8)) - JAE(LabelRef("loop_8")) - } - Label("skip_8") - - CMPQ(n, Imm(4)) - JB(LabelRef("skip_4")) - Label("do_4") - { - temp := GP64() - MOVL(Mem{Base: p}, temp.As32()) - ADDQ(Imm(4), p) - SUBQ(Imm(4), n) - IMULQ(p1, temp) - XORQ(temp, h) - ROLQ(Imm(23), h) - IMULQ(p2, h) - ADDQ(p3, h) - } - Label("skip_4") - - TESTQ(n, n) - JZ(LabelRef("skip_1")) - Label("loop_1") - { - temp := GP64() - MOVBLZX(Mem{Base: p}, temp.As32()) - INCQ(p) - IMULQ(p5, temp) - XORQ(temp, h) - ROLQ(Imm(11), h) - IMULQ(p1, h) - - DECQ(n) - JNZ(LabelRef("loop_1")) - } - Label("skip_1") - - temp := GP64() - MOVQ(h, temp) - SHRQ(Imm(33), temp) - XORQ(temp, h) - - IMULQ(p2, h) - - MOVQ(h, temp) - SHRQ(Imm(29), temp) - XORQ(temp, h) - - IMULQ(p3, h) - - MOVQ(h, temp) - SHRQ(Imm(32), temp) - XORQ(temp, h) - - Store(h, ReturnIndex(0)) - RET() - - Label("zero") - MOVQ(U64(xxhash.Sum64([]byte{})), h) - Store(h, ReturnIndex(0)) - RET() -} - -func writeBlocks() { - TEXT("writeBlocksAvx512", NOSPLIT|NOFRAME, "func(d *[4]uint64, extra *[32]byte, b []byte)") - d := Load(Param("d"), GP64()) - extra := Load(Param("extra"), GP64()) - p := Load(Param("b").Base(), GP64()) - n := Load(Param("b").Len(), GP64()) - - state := YMM() - VMOVDQU(Mem{Base: d, Disp: 0}, state) - - p1, p2, yprime1, yprime2 := GP64(), GP64(), YMM(), YMM() - MOVQ(Imm(prime1), p1) - VPBROADCASTQ(p1, yprime1) - MOVQ(Imm(prime2), p2) - VPBROADCASTQ(p2, yprime2) - - TESTQ(extra, extra) - JZ(LabelRef("skip_extra")) - { - round(state, extra, yprime1, yprime2) - } - Label("skip_extra") - - blockLoop(state, p, n, yprime1, yprime2) - VMOVDQU(state, Mem{Base: d, Disp: 0}) - VZEROUPPER() - RET() -} - -func avx512() { - sum64() - writeBlocks() - Generate() -} diff --git a/gen/go.mod b/gen/go.mod deleted file mode 100644 index 8126eab..0000000 --- a/gen/go.mod +++ /dev/null @@ -1,13 +0,0 @@ -module github.com/cespare/xxhash/v2/gen - -go 1.22 - -require ( - github.com/cespare/xxhash/v2 v2.3.0 - github.com/mmcloughlin/avo v0.6.0 -) - -require ( - golang.org/x/mod v0.14.0 // indirect - golang.org/x/tools v0.16.1 // indirect -) diff --git a/gen/go.sum b/gen/go.sum deleted file mode 100644 index b63110c..0000000 --- a/gen/go.sum +++ /dev/null @@ -1,10 +0,0 @@ -github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= -github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/mmcloughlin/avo v0.6.0 h1:QH6FU8SKoTLaVs80GA8TJuLNkUYl4VokHKlPhVDg4YY= -github.com/mmcloughlin/avo v0.6.0/go.mod h1:8CoAGaCSYXtCPR+8y18Y9aB/kxb8JSS6FRI7mSkvD+8= -golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= -golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= -golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE= -golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= -golang.org/x/tools v0.16.1 h1:TLyB3WofjdOEepBHAU20JdNC1Zbg87elYofWYAY5oZA= -golang.org/x/tools v0.16.1/go.mod h1:kYVVN6I1mBNoB1OX+noeBjbRk4IUEPa7JJ+TJMEooJ0= diff --git a/gen/main.go b/gen/main.go deleted file mode 100644 index d9d42e7..0000000 --- a/gen/main.go +++ /dev/null @@ -1,13 +0,0 @@ -package main - -import "os" - -func main() { - if err := os.Chdir(".."); err != nil { - panic(err) - } - avx512() - if err := slide(); err != nil { - panic(err) - } -} diff --git a/gen/slide.go b/gen/slide.go deleted file mode 100644 index 8797410..0000000 --- a/gen/slide.go +++ /dev/null @@ -1,234 +0,0 @@ -package main - -import ( - "bytes" - "fmt" - "os" - "strings" -) - -const sumSlideSize = 127 -const path = "xxhash_slide.go" - -func slide() error { - w := &bytes.Buffer{} - - fmt.Fprintf(w, `//go:build go1.17 -// +build go1.17 - -package xxhash - -import "math/bits" - -// Generated by gen/slide.go. DO NOT EDIT. - -const slideLength = %d - -// Handles length 0-%d bytes using sum slides. -func slide(b []byte) uint64 { - // This function use sum slides, theses are straight unrolled pieces of code which compute hashes, with middle jumps. - // Each do not contain any conditions to make them trivial for the CPU to parse and never cause any pipeline flushes after the first jump table. - // We need 32 different slides to cover each offset into the 32 block size. The trailing 32 bytes are handled by their own slides which are shared and reused by the higher slides. - // The trailing 32 bytes slides are reused for each offset. The CPUs we care about can always correctly read unconditional jumps without causing a pipeline flush. - - // This function is written more like an optimized assembly routine, except we trick the compiler into generating good code by generating the slide ourself. - // Using the go compiler make the call overhead cheaper since it will use the unstable ABIInternal passing through registers. - // They are also extremely effective when hashing multiple values of the same size back to back. - // Assumptions of this strategy: - // - All the state except b's array will be correctly register allocated. - // It probably generate unnecessary MOVs but the critical path includes LAT3 multiplies for each block, so there is plenty of time to dispatch renames. - // - The compiler is basic block based and will do a good enough job at layout. This is true for some the go compiler, llvm and some of gcc. - // This means I make very liberal use of goto, they shouldn't be red as JMPs but abstract basic blocks links. - // - The compiler has some SSA passes. - // This is used for all the b_* tricks. - // - We can't trust the compiler to inline anything (except intrinsics). - - // Setup variables here since go doesn't want use to do dangerous gotos. - v1 := prime1 - v1 += prime2 - v2 := prime2 - v3 := uint64(0) - v4 := prime1 - v4 = -v4 - h := prime5 - n := uint64(len(b)) - - // The go compiler has multiple oversight in the propragation of proofs through Phi nodes. Using array pointers is a very unsubtle hint and compiles to nothing. - // Because we assume the compiler has some low level SSA passes this is otherwise free. -`, sumSlideSize, sumSlideSize) - for i := 0; i <= sumSlideSize; i++ { - fmt.Fprintf(w, "\tvar b_%d *[%d]byte\n", i, i) - } - - w.WriteString(` - // Jump table to various positions in the slide, this setups proofs for bounds checks. - // From then on it need to make sure to maintain constance in the length of b. - switch len(b) { - case 0: - // Handle this appart because it can be completely folded. - h += n - h ^= h >> 33 - h *= prime2 - h ^= h >> 29 - h *= prime3 - h ^= h >> 32 - return h -`) - for i := 1; i <= sumSlideSize; i++ { - fmt.Fprintf(w, ` case %d: - b_%d = (*[%d]byte)(b) - goto sz_%d -`, i, i, i, i) - } - w.WriteString(` default: - panic("unreachable; slide overflow") - } - - // Theses are the main slides, they handle 32 bytes 4 × 8 bytes at a time using ILP. -`) - // POTENTIAL OPTIMIZATION: We could use a single slide and shuffle v{1,2,3,4} based on offset. This would make setup and transition into trailer more expensive but codesize would be smaller and some i-cache reuse would be certain to happen for anything touching it. - - for k := range 32 { - i := sumSlideSize - k - for ; i >= 32; i -= 32 { - fmt.Fprintf(w, `sz_%d: - { - b := b_%d[:] - var load uint64 -`, i, i) - for r := 1; r <= 4; r++ { - fmt.Fprintf(w, ` load = %s - b = b[8:] -`, load64) - genRound(w, 2, fmt.Sprintf("v%d", r), "load") - } - fmt.Fprintf(w, ` b_%d = (*[%d]byte)(b_%d[32:]) - } - -`, i-32, i-32, i) - // POTENTIAL OPTIMIZATION: b[32:] creates an addition to bump the pointer which means the address dependency on the memory loads is not resolved before the jmp table. I know two fixes: - // - change b to a pointer to the end of the slice and subtract the total offset. I don't know how to do this in pure go. - // - don't bother reusing the slides, this means each load instruction can hardcode the offset. Make the code significantly bigger and i-cache worst, altho I didn't tried it. - } - w.WriteString(` h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) -`) - for r := 1; r <= 4; r++ { - genMergeRound(w, 1, "h", fmt.Sprintf("v%d", r)) - } - w.WriteString("\n") - if i != 0 { // Avoid « label sz_0 defined and not used », case 0 shortcuts with a precomputed value. - fmt.Fprintf(w, "sz_%d:\n", i) - } - fmt.Fprintf(w, ` h += n - goto sz_%dl - -`, i) - } - - w.WriteString(" // Theses are 8 bytes block trailing slides.\n") - for k := range 8 { - i := 31 - k - for ; i >= 8; i -= 8 { - fmt.Fprintf(w, `sz_%dl: - { - b := b_%d[:] - load := %s - var temp uint64 -`, i, i, load64) - genRound(w, 2, "temp", "load") - fmt.Fprintf(w, ` h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_%d = (*[%d]byte)(b_%d[8:]) - } - -`, i-8, i-8, i) - } - fmt.Fprintf(w, ` goto sz_%dl - -`, i) - } - - w.WriteString(" // Theses are the 4 bytes trailing slides.\n") - for k := range 4 { - i := 7 - k - fmt.Fprintf(w, `sz_%dl: - { - b := b_%d[:] - load := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 // Work around for go.dev/issue/68081. - h ^= uint64(load) * prime1 - h = bits.RotateLeft64(h, 23)*prime2 + prime3 - b_%d = (*[%d]byte)(b_%d[4:]) - goto sz_%dl - } - -`, i, i, i-4, i-4, i, i-4) - } - - w.WriteString(" // This is the 1 bytes trailing slide.\n") - for i := 4; i > 1; { - i-- - fmt.Fprintf(w, `sz_%dl: - h ^= uint64(b_%d[0]) * prime5 - h = bits.RotateLeft64(h, 11) * prime1 - b_%d = (*[%d]byte)(b_%d[1:]) - -`, i, i, i-1, i-1, i) - } - // Carefull here, the loop above fallthrough to zero. - - w.WriteString(` // Finally the terminator. -sz_0l: - _ = b_0 // this avoids a bunch of if i != 0 { in codegen and is optimized away. - - h ^= h >> 33 - h *= prime2 - h ^= h >> 29 - h *= prime3 - h ^= h >> 32 - - return h -} -`) - - f, err := os.Create(path) - if err != nil { - return err - } - defer f.Close() - _, err = w.WriteTo(f) - if err != nil { - os.Remove(path) - return err - } - err = f.Close() - if err != nil { - os.Remove(path) - return err - } - - return nil -} - -func genRound(w *bytes.Buffer, tab uint, acc, input string) { - tabs := strings.Repeat("\t", int(tab)) - fmt.Fprintf(w, `%s%s += %s * prime2 -%s%s = bits.RotateLeft64(%s, 31) -%s%s *= prime1 -`, tabs, acc, input, tabs, acc, acc, tabs, acc) -} - -func genMergeRound(w *bytes.Buffer, tab uint, acc, val string) { - tabs := strings.Repeat("\t", int(tab)) - tab++ - tabsp := strings.Repeat("\t", int(tab)) - fmt.Fprintf(w, `%s{ -%svar temp uint64 -`, tabs, tabsp) - genRound(w, tab, "temp", val) - fmt.Fprintf(w, `%s%s ^= temp -%s%s = %s*prime1 + prime4 -%s} -`, tabsp, acc, tabsp, acc, acc, tabs) -} - -const load64 = "uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081." diff --git a/xxhash_asm_amd64.go b/xxhash_asm_amd64.go index b04a614..d594363 100644 --- a/xxhash_asm_amd64.go +++ b/xxhash_asm_amd64.go @@ -1,8 +1,6 @@ //go:build amd64 && !appengine && gc && !purego // +build amd64,!appengine,gc,!purego -//go:generate sh -c "cd gen && go run -tags purego . -out xxhash_avx512_amd64.s" - package xxhash import "github.com/klauspost/cpuid/v2" @@ -23,36 +21,11 @@ var useAvx512 = cpuid.CPU.Supports( ) && cpuid.CPU.IsVendor(cpuid.AMD) // Sum64 computes the 64-bit xxHash digest of b with a zero seed. -func Sum64(b []byte) uint64 { - if slideLength != 0 { - // If we don't have the slide sum small blocks are much slower. - if len(b) <= slideLength { - return slide(b) - } - if useAvx512 { - return sum64Avx512(b) - } - } - return sum64Scalar(b) -} - -//go:noescape -func sum64Scalar(b []byte) uint64 - +// //go:noescape -func sum64Avx512(b []byte) uint64 +func Sum64(b []byte) uint64 // extra is a first block before b, it may be nil then skip it. -func writeBlocks(d *Digest, extra *[32]byte, b []byte) { - if useAvx512 { - writeBlocksAvx512(&d.s, extra, b) - return - } - writeBlocksScalar(d, nil, b) -} - -//go:noescape -func writeBlocksAvx512(d *[4]uint64, extra *[32]byte, b []byte) - +// //go:noescape -func writeBlocksScalar(d *Digest, extra *[32]byte, b []byte) +func writeBlocks(d *Digest, extra *[32]byte, b []byte) diff --git a/xxhash_avx512_amd64.s b/xxhash_avx512_amd64.s index 01fd0d6..b740c32 100644 --- a/xxhash_avx512_amd64.s +++ b/xxhash_avx512_amd64.s @@ -1,4 +1,7 @@ -// Code generated by command: go run main.go -out xxhash_avx512_amd64.s. DO NOT EDIT. +//go:build !appengine && gc && !purego +// +build !appengine +// +build gc +// +build !purego #include "textflag.h" @@ -8,183 +11,204 @@ DATA ·initWideAvx512<>+16(SB)/8, $0x0000000000000000 DATA ·initWideAvx512<>+24(SB)/8, $0x61c8864e7a143579 GLOBL ·initWideAvx512<>(SB), NOSPLIT|NOPTR, $32 -// func sum64Avx512(b []byte) uint64 +#define p SI +#define h AX +#define end DI +#define temp BX +#define prime1 DX +#define prime2 R8 + +#define state Y0 +#define xstate X0 +#define yprime1 Y1 +#define yprime2 Y2 +#define ytemp Y3 +#define xtemp X3 + +#define yround() \ + VPMULLQ ytemp, yprime2, ytemp \ + VPADDQ ytemp, state, state \ + VPROLQ $31, state, state \ + VPMULLQ state, yprime1, state \ + +#define blockLoop(length) \ + MOVL $0x1f, end \ + ANDNQ length, end, end \ + ADDQ p, end \ + PCALIGN $64 \ +loop_32: \ + VMOVDQU (p), ytemp \ + yround() \ + ADDQ $32, p \ + CMPQ p, end \ + JNE loop_32 + +#define n CX +#define prime3 R9 +#define prime4 R10 +#define prime5 R11 + +// lateMergeRound performs mergeRound on h given the value from round0 +#define lateMergeRound(v) \ + XORQ v, h \ + IMULQ prime1, h \ + ADDQ prime4, h + +// func Sum64(b []byte) uint64 // Requires: AVX, AVX2, AVX512DQ, AVX512F, AVX512VL, BMI -TEXT ·sum64Avx512(SB), NOSPLIT|NOFRAME, $0-32 - MOVQ b_base+0(FP), AX - MOVQ b_len+8(FP), CX - MOVQ $0x9e3779b185ebca87, DX - MOVQ $0xc2b2ae3d27d4eb4f, BX - MOVQ $0x165667b19e3779f9, SI - MOVQ $0x85ebca77c2b2ae63, DI - MOVQ $0x27d4eb2f165667c5, R8 - LEAQ (R8)(CX*1), R9 - TESTQ CX, CX - JZ zero - CMPQ CX, $0x03 +TEXT ·Sum64(SB), NOSPLIT|NOFRAME, $0-32 + CMPB ·useAvx512(SB), $0x00 + JNE do_avx512 + JMP ·sum64Scalar(SB) +zero: + MOVQ $0xef46db3751d8e999, h + MOVQ h, ret+24(FP) + RET + +do_avx512: + MOVQ b_base+0(FP), p + MOVQ b_len+8(FP), n + MOVQ $0x9e3779b185ebca87, prime1 + MOVQ $0xc2b2ae3d27d4eb4f, prime2 + MOVQ $0x165667b19e3779f9, prime3 + MOVQ $0x85ebca77c2b2ae63, prime4 + MOVQ $0x27d4eb2f165667c5, prime5 + + LEAQ (prime5)(n*1), h // precompute h for the shortcuts + JCXZQ zero + CMPQ n, $3 JBE loop_1 - CMPQ CX, $0x07 + CMPQ n, $7 JBE do_4 - CMPQ CX, $0x1f + CMPQ n, $31 JBE loop_8 - VMOVDQU ·initWideAvx512<>+0(SB), Y0 - VPBROADCASTQ DX, Y1 - VPBROADCASTQ BX, Y2 - MOVL $0x0000001f, R9 - ANDNQ CX, R9, R9 - ADDQ AX, R9 - -loop_32: - VMOVDQU (AX), Y3 - VPMULLQ Y3, Y2, Y3 - VPADDQ Y3, Y0, Y0 - VPROLQ $0x1f, Y0, Y0 - VPMULLQ Y0, Y1, Y0 - ADDQ $0x20, AX - CMPQ AX, R9 - JNE loop_32 - VMOVQ X0, R10 - MOVQ R10, R9 - ROLQ $0x01, R9 - VPEXTRQ $0x01, X0, R11 - MOVQ R11, R14 - ROLQ $0x07, R14 - ADDQ R14, R9 - VEXTRACTI128 $0x01, Y0, X0 - VMOVQ X0, R12 - MOVQ R12, R14 - ROLQ $0x0c, R14 - ADDQ R14, R9 - VPEXTRQ $0x01, X0, R13 + + VMOVDQU ·initWideAvx512<>+0(SB), state + VPBROADCASTQ prime1, yprime1 + VPBROADCASTQ prime2, yprime2 + + blockLoop(n) + + VMOVQ xstate, h + ROLQ $1, h + + VPEXTRQ $1, xstate, temp + ROLQ $7, temp + ADDQ temp, h + + VEXTRACTI128 $1, state, xtemp + VMOVQ xtemp, temp + ROLQ $12, temp + ADDQ temp, h + + VPEXTRQ $1, xtemp, temp + ROLQ $18, temp + ADDQ temp, h + + // round0 for mergeRound + VPMULLQ yprime2, state, state + VPROLQ $0x1f, state, state + VPMULLQ yprime1, state, state + + VMOVQ xstate, temp + lateMergeRound(temp) + + VPEXTRQ $1, xstate, temp + lateMergeRound(temp) + + VEXTRACTI128 $1, state, xtemp + VMOVQ xtemp, temp + lateMergeRound(temp) + + VPEXTRQ $1, xtemp, temp VZEROUPPER - MOVQ R13, R14 - ROLQ $0x12, R14 - ADDQ R14, R9 - IMULQ BX, R10 - ROLQ $0x1f, R10 - IMULQ DX, R10 - XORQ R10, R9 - IMULQ DX, R9 - ADDQ DI, R9 - IMULQ BX, R11 - ROLQ $0x1f, R11 - IMULQ DX, R11 - XORQ R11, R9 - IMULQ DX, R9 - ADDQ DI, R9 - IMULQ BX, R12 - ROLQ $0x1f, R12 - IMULQ DX, R12 - XORQ R12, R9 - IMULQ DX, R9 - ADDQ DI, R9 - IMULQ BX, R13 - ROLQ $0x1f, R13 - IMULQ DX, R13 - XORQ R13, R9 - IMULQ DX, R9 - ADDQ DI, R9 - ADDQ CX, R9 - ANDQ $0x1f, CX - CMPQ CX, $0x08 - JB skip_8 + lateMergeRound(temp) + + ADDQ n, h + ANDQ $0x1f, n + CMPQ n, $8 + JB skip_8 loop_8: - MOVQ (AX), R10 - ADDQ $0x08, AX - SUBQ $0x08, CX - IMULQ BX, R10 - ROLQ $0x1f, R10 - IMULQ DX, R10 - XORQ R10, R9 - ROLQ $0x1b, R9 - IMULQ DX, R9 - ADDQ DI, R9 - CMPQ CX, $0x08 + MOVQ (p), temp + ADDQ $8, p + SUBQ $8, n + IMULQ prime2, temp + ROLQ $31, temp + IMULQ prime1, temp + XORQ temp, h + ROLQ $27, h + IMULQ prime1, h + ADDQ prime4, h + CMPQ n, $8 JAE loop_8 - skip_8: - CMPQ CX, $0x04 - JB skip_4 + CMPQ n, $4 + JB skip_4 do_4: - MOVL (AX), DI - ADDQ $0x04, AX - SUBQ $0x04, CX - IMULQ DX, DI - XORQ DI, R9 - ROLQ $0x17, R9 - IMULQ BX, R9 - ADDQ SI, R9 - + MOVL (p), temp + ADDQ $4, p + SUBQ $4, n + IMULQ prime1, temp + XORQ temp, h + ROLQ $23, h + IMULQ prime2, h + ADDQ prime3, h skip_4: - TESTQ CX, CX - JZ skip_1 + JCXZQ skip_1 loop_1: - MOVBLZX (AX), DI - INCQ AX - IMULQ R8, DI - XORQ DI, R9 - ROLQ $0x0b, R9 - IMULQ DX, R9 - DECQ CX - JNZ loop_1 - + MOVBLZX (p), temp + INCQ p + IMULQ prime5, temp + XORQ temp, h + ROLQ $0x0b, h + IMULQ prime1, h + DECQ n + JNZ loop_1 // could be a LOOP but go tool asm wont assemble it :'( skip_1: - MOVQ R9, AX - SHRQ $0x21, AX - XORQ AX, R9 - IMULQ BX, R9 - MOVQ R9, AX - SHRQ $0x1d, AX - XORQ AX, R9 - IMULQ SI, R9 - MOVQ R9, AX - SHRQ $0x20, AX - XORQ AX, R9 - MOVQ R9, ret+24(FP) - RET -zero: - MOVQ $0xef46db3751d8e999, R9 - MOVQ R9, ret+24(FP) + MOVQ h, temp + SHRQ $33, temp + XORQ temp, h + IMULQ prime2, h + MOVQ h, temp + SHRQ $29, temp + XORQ temp, h + IMULQ prime3, h + MOVQ h, temp + SHRQ $32, temp + XORQ temp, h + MOVQ h, ret+24(FP) RET +#define extrap CX +#define l R9 + // func writeBlocksAvx512(d *[4]uint64, extra *[32]byte, b []byte) // Requires: AVX, AVX2, AVX512DQ, AVX512F, AVX512VL, BMI -TEXT ·writeBlocksAvx512(SB), NOSPLIT|NOFRAME, $0-40 - MOVQ d+0(FP), AX - MOVQ extra+8(FP), CX - MOVQ b_base+16(FP), DX - MOVQ b_len+24(FP), BX - VMOVDQU (AX), Y0 - MOVQ $0x9e3779b185ebca87, SI - VPBROADCASTQ SI, Y1 - MOVQ $0xc2b2ae3d27d4eb4f, SI - VPBROADCASTQ SI, Y2 - TESTQ CX, CX - JZ skip_extra - VMOVDQU (CX), Y3 - VPMULLQ Y3, Y2, Y3 - VPADDQ Y3, Y0, Y0 - VPROLQ $0x1f, Y0, Y0 - VPMULLQ Y0, Y1, Y0 +TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40 + CMPB ·useAvx512(SB), $0x00 + JNE do_avx512 + JMP ·writeBlocksScalar(SB) + +do_avx512: + MOVQ d+0(FP), h + MOVQ extra+8(FP), extrap + MOVQ b_base+16(FP), p + MOVQ b_len+24(FP), l + VMOVDQU (h), state + MOVQ $0x9e3779b185ebca87, prime1 + VPBROADCASTQ prime1, yprime1 + MOVQ $0xc2b2ae3d27d4eb4f, prime2 + VPBROADCASTQ prime2, yprime2 + JCXZQ skip_extra + VMOVDQU (extrap), ytemp + yround() skip_extra: - MOVL $0x0000001f, CX - ANDNQ BX, CX, CX - ADDQ DX, CX - -loop_32: - VMOVDQU (DX), Y3 - VPMULLQ Y3, Y2, Y3 - VPADDQ Y3, Y0, Y0 - VPROLQ $0x1f, Y0, Y0 - VPMULLQ Y0, Y1, Y0 - ADDQ $0x20, DX - CMPQ DX, CX - JNE loop_32 - VMOVDQU Y0, (AX) + blockLoop(l) + VMOVDQU state, (h) VZEROUPPER RET diff --git a/xxhash_not_slide.go b/xxhash_not_slide.go deleted file mode 100644 index 9a75e94..0000000 --- a/xxhash_not_slide.go +++ /dev/null @@ -1,10 +0,0 @@ -//go:build !go1.17 -// +build !go1.17 - -package xxhash - -const slideLength = 0 - -func slide(b []byte) uint64 { - panic("unreachable") -} diff --git a/xxhash_slide.go b/xxhash_slide.go deleted file mode 100644 index c4a76a2..0000000 --- a/xxhash_slide.go +++ /dev/null @@ -1,4774 +0,0 @@ -//go:build go1.17 -// +build go1.17 - -package xxhash - -import "math/bits" - -// Generated by gen/slide.go. DO NOT EDIT. - -const slideLength = 127 - -// Handles length 0-127 bytes using sum slides. -func slide(b []byte) uint64 { - // This function use sum slides, theses are straight unrolled pieces of code which compute hashes, with middle jumps. - // Each do not contain any conditions to make them trivial for the CPU to parse and never cause any pipeline flushes after the first jump table. - // We need 32 different slides to cover each offset into the 32 block size. The trailing 32 bytes are handled by their own slides which are shared and reused by the higher slides. - // The trailing 32 bytes slides are reused for each offset. The CPUs we care about can always correctly read unconditional jumps without causing a pipeline flush. - - // This function is written more like an optimized assembly routine, except we trick the compiler into generating good code by generating the slide ourself. - // Using the go compiler make the call overhead cheaper since it will use the unstable ABIInternal passing through registers. - // They are also extremely effective when hashing multiple values of the same size back to back. - // Assumptions of this strategy: - // - All the state except b's array will be correctly register allocated. - // It probably generate unnecessary MOVs but the critical path includes LAT3 multiplies for each block, so there is plenty of time to dispatch renames. - // - The compiler is basic block based and will do a good enough job at layout. This is true for some the go compiler, llvm and some of gcc. - // This means I make very liberal use of goto, they shouldn't be red as JMPs but abstract basic blocks links. - // - The compiler has some SSA passes. - // This is used for all the b_* tricks. - // - We can't trust the compiler to inline anything (except intrinsics). - - // Setup variables here since go doesn't want use to do dangerous gotos. - v1 := prime1 - v1 += prime2 - v2 := prime2 - v3 := uint64(0) - v4 := prime1 - v4 = -v4 - h := prime5 - n := uint64(len(b)) - - // The go compiler has multiple oversight in the propragation of proofs through Phi nodes. Using array pointers is a very unsubtle hint and compiles to nothing. - // Because we assume the compiler has some low level SSA passes this is otherwise free. - var b_0 *[0]byte - var b_1 *[1]byte - var b_2 *[2]byte - var b_3 *[3]byte - var b_4 *[4]byte - var b_5 *[5]byte - var b_6 *[6]byte - var b_7 *[7]byte - var b_8 *[8]byte - var b_9 *[9]byte - var b_10 *[10]byte - var b_11 *[11]byte - var b_12 *[12]byte - var b_13 *[13]byte - var b_14 *[14]byte - var b_15 *[15]byte - var b_16 *[16]byte - var b_17 *[17]byte - var b_18 *[18]byte - var b_19 *[19]byte - var b_20 *[20]byte - var b_21 *[21]byte - var b_22 *[22]byte - var b_23 *[23]byte - var b_24 *[24]byte - var b_25 *[25]byte - var b_26 *[26]byte - var b_27 *[27]byte - var b_28 *[28]byte - var b_29 *[29]byte - var b_30 *[30]byte - var b_31 *[31]byte - var b_32 *[32]byte - var b_33 *[33]byte - var b_34 *[34]byte - var b_35 *[35]byte - var b_36 *[36]byte - var b_37 *[37]byte - var b_38 *[38]byte - var b_39 *[39]byte - var b_40 *[40]byte - var b_41 *[41]byte - var b_42 *[42]byte - var b_43 *[43]byte - var b_44 *[44]byte - var b_45 *[45]byte - var b_46 *[46]byte - var b_47 *[47]byte - var b_48 *[48]byte - var b_49 *[49]byte - var b_50 *[50]byte - var b_51 *[51]byte - var b_52 *[52]byte - var b_53 *[53]byte - var b_54 *[54]byte - var b_55 *[55]byte - var b_56 *[56]byte - var b_57 *[57]byte - var b_58 *[58]byte - var b_59 *[59]byte - var b_60 *[60]byte - var b_61 *[61]byte - var b_62 *[62]byte - var b_63 *[63]byte - var b_64 *[64]byte - var b_65 *[65]byte - var b_66 *[66]byte - var b_67 *[67]byte - var b_68 *[68]byte - var b_69 *[69]byte - var b_70 *[70]byte - var b_71 *[71]byte - var b_72 *[72]byte - var b_73 *[73]byte - var b_74 *[74]byte - var b_75 *[75]byte - var b_76 *[76]byte - var b_77 *[77]byte - var b_78 *[78]byte - var b_79 *[79]byte - var b_80 *[80]byte - var b_81 *[81]byte - var b_82 *[82]byte - var b_83 *[83]byte - var b_84 *[84]byte - var b_85 *[85]byte - var b_86 *[86]byte - var b_87 *[87]byte - var b_88 *[88]byte - var b_89 *[89]byte - var b_90 *[90]byte - var b_91 *[91]byte - var b_92 *[92]byte - var b_93 *[93]byte - var b_94 *[94]byte - var b_95 *[95]byte - var b_96 *[96]byte - var b_97 *[97]byte - var b_98 *[98]byte - var b_99 *[99]byte - var b_100 *[100]byte - var b_101 *[101]byte - var b_102 *[102]byte - var b_103 *[103]byte - var b_104 *[104]byte - var b_105 *[105]byte - var b_106 *[106]byte - var b_107 *[107]byte - var b_108 *[108]byte - var b_109 *[109]byte - var b_110 *[110]byte - var b_111 *[111]byte - var b_112 *[112]byte - var b_113 *[113]byte - var b_114 *[114]byte - var b_115 *[115]byte - var b_116 *[116]byte - var b_117 *[117]byte - var b_118 *[118]byte - var b_119 *[119]byte - var b_120 *[120]byte - var b_121 *[121]byte - var b_122 *[122]byte - var b_123 *[123]byte - var b_124 *[124]byte - var b_125 *[125]byte - var b_126 *[126]byte - var b_127 *[127]byte - - // Jump table to various positions in the slide, this setups proofs for bounds checks. - // From then on it need to make sure to maintain constance in the length of b. - switch len(b) { - case 0: - // Handle this appart because it can be completely folded. - h += n - h ^= h >> 33 - h *= prime2 - h ^= h >> 29 - h *= prime3 - h ^= h >> 32 - return h - case 1: - b_1 = (*[1]byte)(b) - goto sz_1 - case 2: - b_2 = (*[2]byte)(b) - goto sz_2 - case 3: - b_3 = (*[3]byte)(b) - goto sz_3 - case 4: - b_4 = (*[4]byte)(b) - goto sz_4 - case 5: - b_5 = (*[5]byte)(b) - goto sz_5 - case 6: - b_6 = (*[6]byte)(b) - goto sz_6 - case 7: - b_7 = (*[7]byte)(b) - goto sz_7 - case 8: - b_8 = (*[8]byte)(b) - goto sz_8 - case 9: - b_9 = (*[9]byte)(b) - goto sz_9 - case 10: - b_10 = (*[10]byte)(b) - goto sz_10 - case 11: - b_11 = (*[11]byte)(b) - goto sz_11 - case 12: - b_12 = (*[12]byte)(b) - goto sz_12 - case 13: - b_13 = (*[13]byte)(b) - goto sz_13 - case 14: - b_14 = (*[14]byte)(b) - goto sz_14 - case 15: - b_15 = (*[15]byte)(b) - goto sz_15 - case 16: - b_16 = (*[16]byte)(b) - goto sz_16 - case 17: - b_17 = (*[17]byte)(b) - goto sz_17 - case 18: - b_18 = (*[18]byte)(b) - goto sz_18 - case 19: - b_19 = (*[19]byte)(b) - goto sz_19 - case 20: - b_20 = (*[20]byte)(b) - goto sz_20 - case 21: - b_21 = (*[21]byte)(b) - goto sz_21 - case 22: - b_22 = (*[22]byte)(b) - goto sz_22 - case 23: - b_23 = (*[23]byte)(b) - goto sz_23 - case 24: - b_24 = (*[24]byte)(b) - goto sz_24 - case 25: - b_25 = (*[25]byte)(b) - goto sz_25 - case 26: - b_26 = (*[26]byte)(b) - goto sz_26 - case 27: - b_27 = (*[27]byte)(b) - goto sz_27 - case 28: - b_28 = (*[28]byte)(b) - goto sz_28 - case 29: - b_29 = (*[29]byte)(b) - goto sz_29 - case 30: - b_30 = (*[30]byte)(b) - goto sz_30 - case 31: - b_31 = (*[31]byte)(b) - goto sz_31 - case 32: - b_32 = (*[32]byte)(b) - goto sz_32 - case 33: - b_33 = (*[33]byte)(b) - goto sz_33 - case 34: - b_34 = (*[34]byte)(b) - goto sz_34 - case 35: - b_35 = (*[35]byte)(b) - goto sz_35 - case 36: - b_36 = (*[36]byte)(b) - goto sz_36 - case 37: - b_37 = (*[37]byte)(b) - goto sz_37 - case 38: - b_38 = (*[38]byte)(b) - goto sz_38 - case 39: - b_39 = (*[39]byte)(b) - goto sz_39 - case 40: - b_40 = (*[40]byte)(b) - goto sz_40 - case 41: - b_41 = (*[41]byte)(b) - goto sz_41 - case 42: - b_42 = (*[42]byte)(b) - goto sz_42 - case 43: - b_43 = (*[43]byte)(b) - goto sz_43 - case 44: - b_44 = (*[44]byte)(b) - goto sz_44 - case 45: - b_45 = (*[45]byte)(b) - goto sz_45 - case 46: - b_46 = (*[46]byte)(b) - goto sz_46 - case 47: - b_47 = (*[47]byte)(b) - goto sz_47 - case 48: - b_48 = (*[48]byte)(b) - goto sz_48 - case 49: - b_49 = (*[49]byte)(b) - goto sz_49 - case 50: - b_50 = (*[50]byte)(b) - goto sz_50 - case 51: - b_51 = (*[51]byte)(b) - goto sz_51 - case 52: - b_52 = (*[52]byte)(b) - goto sz_52 - case 53: - b_53 = (*[53]byte)(b) - goto sz_53 - case 54: - b_54 = (*[54]byte)(b) - goto sz_54 - case 55: - b_55 = (*[55]byte)(b) - goto sz_55 - case 56: - b_56 = (*[56]byte)(b) - goto sz_56 - case 57: - b_57 = (*[57]byte)(b) - goto sz_57 - case 58: - b_58 = (*[58]byte)(b) - goto sz_58 - case 59: - b_59 = (*[59]byte)(b) - goto sz_59 - case 60: - b_60 = (*[60]byte)(b) - goto sz_60 - case 61: - b_61 = (*[61]byte)(b) - goto sz_61 - case 62: - b_62 = (*[62]byte)(b) - goto sz_62 - case 63: - b_63 = (*[63]byte)(b) - goto sz_63 - case 64: - b_64 = (*[64]byte)(b) - goto sz_64 - case 65: - b_65 = (*[65]byte)(b) - goto sz_65 - case 66: - b_66 = (*[66]byte)(b) - goto sz_66 - case 67: - b_67 = (*[67]byte)(b) - goto sz_67 - case 68: - b_68 = (*[68]byte)(b) - goto sz_68 - case 69: - b_69 = (*[69]byte)(b) - goto sz_69 - case 70: - b_70 = (*[70]byte)(b) - goto sz_70 - case 71: - b_71 = (*[71]byte)(b) - goto sz_71 - case 72: - b_72 = (*[72]byte)(b) - goto sz_72 - case 73: - b_73 = (*[73]byte)(b) - goto sz_73 - case 74: - b_74 = (*[74]byte)(b) - goto sz_74 - case 75: - b_75 = (*[75]byte)(b) - goto sz_75 - case 76: - b_76 = (*[76]byte)(b) - goto sz_76 - case 77: - b_77 = (*[77]byte)(b) - goto sz_77 - case 78: - b_78 = (*[78]byte)(b) - goto sz_78 - case 79: - b_79 = (*[79]byte)(b) - goto sz_79 - case 80: - b_80 = (*[80]byte)(b) - goto sz_80 - case 81: - b_81 = (*[81]byte)(b) - goto sz_81 - case 82: - b_82 = (*[82]byte)(b) - goto sz_82 - case 83: - b_83 = (*[83]byte)(b) - goto sz_83 - case 84: - b_84 = (*[84]byte)(b) - goto sz_84 - case 85: - b_85 = (*[85]byte)(b) - goto sz_85 - case 86: - b_86 = (*[86]byte)(b) - goto sz_86 - case 87: - b_87 = (*[87]byte)(b) - goto sz_87 - case 88: - b_88 = (*[88]byte)(b) - goto sz_88 - case 89: - b_89 = (*[89]byte)(b) - goto sz_89 - case 90: - b_90 = (*[90]byte)(b) - goto sz_90 - case 91: - b_91 = (*[91]byte)(b) - goto sz_91 - case 92: - b_92 = (*[92]byte)(b) - goto sz_92 - case 93: - b_93 = (*[93]byte)(b) - goto sz_93 - case 94: - b_94 = (*[94]byte)(b) - goto sz_94 - case 95: - b_95 = (*[95]byte)(b) - goto sz_95 - case 96: - b_96 = (*[96]byte)(b) - goto sz_96 - case 97: - b_97 = (*[97]byte)(b) - goto sz_97 - case 98: - b_98 = (*[98]byte)(b) - goto sz_98 - case 99: - b_99 = (*[99]byte)(b) - goto sz_99 - case 100: - b_100 = (*[100]byte)(b) - goto sz_100 - case 101: - b_101 = (*[101]byte)(b) - goto sz_101 - case 102: - b_102 = (*[102]byte)(b) - goto sz_102 - case 103: - b_103 = (*[103]byte)(b) - goto sz_103 - case 104: - b_104 = (*[104]byte)(b) - goto sz_104 - case 105: - b_105 = (*[105]byte)(b) - goto sz_105 - case 106: - b_106 = (*[106]byte)(b) - goto sz_106 - case 107: - b_107 = (*[107]byte)(b) - goto sz_107 - case 108: - b_108 = (*[108]byte)(b) - goto sz_108 - case 109: - b_109 = (*[109]byte)(b) - goto sz_109 - case 110: - b_110 = (*[110]byte)(b) - goto sz_110 - case 111: - b_111 = (*[111]byte)(b) - goto sz_111 - case 112: - b_112 = (*[112]byte)(b) - goto sz_112 - case 113: - b_113 = (*[113]byte)(b) - goto sz_113 - case 114: - b_114 = (*[114]byte)(b) - goto sz_114 - case 115: - b_115 = (*[115]byte)(b) - goto sz_115 - case 116: - b_116 = (*[116]byte)(b) - goto sz_116 - case 117: - b_117 = (*[117]byte)(b) - goto sz_117 - case 118: - b_118 = (*[118]byte)(b) - goto sz_118 - case 119: - b_119 = (*[119]byte)(b) - goto sz_119 - case 120: - b_120 = (*[120]byte)(b) - goto sz_120 - case 121: - b_121 = (*[121]byte)(b) - goto sz_121 - case 122: - b_122 = (*[122]byte)(b) - goto sz_122 - case 123: - b_123 = (*[123]byte)(b) - goto sz_123 - case 124: - b_124 = (*[124]byte)(b) - goto sz_124 - case 125: - b_125 = (*[125]byte)(b) - goto sz_125 - case 126: - b_126 = (*[126]byte)(b) - goto sz_126 - case 127: - b_127 = (*[127]byte)(b) - goto sz_127 - default: - panic("unreachable; slide overflow") - } - - // Theses are the main slides, they handle 32 bytes 4 × 8 bytes at a time using ILP. -sz_127: - { - b := b_127[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_95 = (*[95]byte)(b_127[32:]) - } - -sz_95: - { - b := b_95[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_63 = (*[63]byte)(b_95[32:]) - } - -sz_63: - { - b := b_63[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_31 = (*[31]byte)(b_63[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_31: - h += n - goto sz_31l - -sz_126: - { - b := b_126[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_94 = (*[94]byte)(b_126[32:]) - } - -sz_94: - { - b := b_94[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_62 = (*[62]byte)(b_94[32:]) - } - -sz_62: - { - b := b_62[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_30 = (*[30]byte)(b_62[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_30: - h += n - goto sz_30l - -sz_125: - { - b := b_125[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_93 = (*[93]byte)(b_125[32:]) - } - -sz_93: - { - b := b_93[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_61 = (*[61]byte)(b_93[32:]) - } - -sz_61: - { - b := b_61[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_29 = (*[29]byte)(b_61[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_29: - h += n - goto sz_29l - -sz_124: - { - b := b_124[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_92 = (*[92]byte)(b_124[32:]) - } - -sz_92: - { - b := b_92[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_60 = (*[60]byte)(b_92[32:]) - } - -sz_60: - { - b := b_60[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_28 = (*[28]byte)(b_60[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_28: - h += n - goto sz_28l - -sz_123: - { - b := b_123[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_91 = (*[91]byte)(b_123[32:]) - } - -sz_91: - { - b := b_91[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_59 = (*[59]byte)(b_91[32:]) - } - -sz_59: - { - b := b_59[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_27 = (*[27]byte)(b_59[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_27: - h += n - goto sz_27l - -sz_122: - { - b := b_122[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_90 = (*[90]byte)(b_122[32:]) - } - -sz_90: - { - b := b_90[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_58 = (*[58]byte)(b_90[32:]) - } - -sz_58: - { - b := b_58[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_26 = (*[26]byte)(b_58[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_26: - h += n - goto sz_26l - -sz_121: - { - b := b_121[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_89 = (*[89]byte)(b_121[32:]) - } - -sz_89: - { - b := b_89[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_57 = (*[57]byte)(b_89[32:]) - } - -sz_57: - { - b := b_57[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_25 = (*[25]byte)(b_57[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_25: - h += n - goto sz_25l - -sz_120: - { - b := b_120[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_88 = (*[88]byte)(b_120[32:]) - } - -sz_88: - { - b := b_88[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_56 = (*[56]byte)(b_88[32:]) - } - -sz_56: - { - b := b_56[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_24 = (*[24]byte)(b_56[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_24: - h += n - goto sz_24l - -sz_119: - { - b := b_119[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_87 = (*[87]byte)(b_119[32:]) - } - -sz_87: - { - b := b_87[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_55 = (*[55]byte)(b_87[32:]) - } - -sz_55: - { - b := b_55[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_23 = (*[23]byte)(b_55[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_23: - h += n - goto sz_23l - -sz_118: - { - b := b_118[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_86 = (*[86]byte)(b_118[32:]) - } - -sz_86: - { - b := b_86[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_54 = (*[54]byte)(b_86[32:]) - } - -sz_54: - { - b := b_54[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_22 = (*[22]byte)(b_54[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_22: - h += n - goto sz_22l - -sz_117: - { - b := b_117[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_85 = (*[85]byte)(b_117[32:]) - } - -sz_85: - { - b := b_85[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_53 = (*[53]byte)(b_85[32:]) - } - -sz_53: - { - b := b_53[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_21 = (*[21]byte)(b_53[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_21: - h += n - goto sz_21l - -sz_116: - { - b := b_116[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_84 = (*[84]byte)(b_116[32:]) - } - -sz_84: - { - b := b_84[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_52 = (*[52]byte)(b_84[32:]) - } - -sz_52: - { - b := b_52[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_20 = (*[20]byte)(b_52[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_20: - h += n - goto sz_20l - -sz_115: - { - b := b_115[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_83 = (*[83]byte)(b_115[32:]) - } - -sz_83: - { - b := b_83[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_51 = (*[51]byte)(b_83[32:]) - } - -sz_51: - { - b := b_51[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_19 = (*[19]byte)(b_51[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_19: - h += n - goto sz_19l - -sz_114: - { - b := b_114[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_82 = (*[82]byte)(b_114[32:]) - } - -sz_82: - { - b := b_82[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_50 = (*[50]byte)(b_82[32:]) - } - -sz_50: - { - b := b_50[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_18 = (*[18]byte)(b_50[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_18: - h += n - goto sz_18l - -sz_113: - { - b := b_113[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_81 = (*[81]byte)(b_113[32:]) - } - -sz_81: - { - b := b_81[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_49 = (*[49]byte)(b_81[32:]) - } - -sz_49: - { - b := b_49[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_17 = (*[17]byte)(b_49[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_17: - h += n - goto sz_17l - -sz_112: - { - b := b_112[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_80 = (*[80]byte)(b_112[32:]) - } - -sz_80: - { - b := b_80[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_48 = (*[48]byte)(b_80[32:]) - } - -sz_48: - { - b := b_48[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_16 = (*[16]byte)(b_48[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_16: - h += n - goto sz_16l - -sz_111: - { - b := b_111[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_79 = (*[79]byte)(b_111[32:]) - } - -sz_79: - { - b := b_79[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_47 = (*[47]byte)(b_79[32:]) - } - -sz_47: - { - b := b_47[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_15 = (*[15]byte)(b_47[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_15: - h += n - goto sz_15l - -sz_110: - { - b := b_110[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_78 = (*[78]byte)(b_110[32:]) - } - -sz_78: - { - b := b_78[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_46 = (*[46]byte)(b_78[32:]) - } - -sz_46: - { - b := b_46[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_14 = (*[14]byte)(b_46[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_14: - h += n - goto sz_14l - -sz_109: - { - b := b_109[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_77 = (*[77]byte)(b_109[32:]) - } - -sz_77: - { - b := b_77[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_45 = (*[45]byte)(b_77[32:]) - } - -sz_45: - { - b := b_45[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_13 = (*[13]byte)(b_45[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_13: - h += n - goto sz_13l - -sz_108: - { - b := b_108[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_76 = (*[76]byte)(b_108[32:]) - } - -sz_76: - { - b := b_76[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_44 = (*[44]byte)(b_76[32:]) - } - -sz_44: - { - b := b_44[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_12 = (*[12]byte)(b_44[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_12: - h += n - goto sz_12l - -sz_107: - { - b := b_107[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_75 = (*[75]byte)(b_107[32:]) - } - -sz_75: - { - b := b_75[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_43 = (*[43]byte)(b_75[32:]) - } - -sz_43: - { - b := b_43[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_11 = (*[11]byte)(b_43[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_11: - h += n - goto sz_11l - -sz_106: - { - b := b_106[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_74 = (*[74]byte)(b_106[32:]) - } - -sz_74: - { - b := b_74[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_42 = (*[42]byte)(b_74[32:]) - } - -sz_42: - { - b := b_42[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_10 = (*[10]byte)(b_42[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_10: - h += n - goto sz_10l - -sz_105: - { - b := b_105[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_73 = (*[73]byte)(b_105[32:]) - } - -sz_73: - { - b := b_73[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_41 = (*[41]byte)(b_73[32:]) - } - -sz_41: - { - b := b_41[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_9 = (*[9]byte)(b_41[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_9: - h += n - goto sz_9l - -sz_104: - { - b := b_104[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_72 = (*[72]byte)(b_104[32:]) - } - -sz_72: - { - b := b_72[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_40 = (*[40]byte)(b_72[32:]) - } - -sz_40: - { - b := b_40[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_8 = (*[8]byte)(b_40[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_8: - h += n - goto sz_8l - -sz_103: - { - b := b_103[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_71 = (*[71]byte)(b_103[32:]) - } - -sz_71: - { - b := b_71[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_39 = (*[39]byte)(b_71[32:]) - } - -sz_39: - { - b := b_39[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_7 = (*[7]byte)(b_39[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_7: - h += n - goto sz_7l - -sz_102: - { - b := b_102[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_70 = (*[70]byte)(b_102[32:]) - } - -sz_70: - { - b := b_70[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_38 = (*[38]byte)(b_70[32:]) - } - -sz_38: - { - b := b_38[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_6 = (*[6]byte)(b_38[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_6: - h += n - goto sz_6l - -sz_101: - { - b := b_101[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_69 = (*[69]byte)(b_101[32:]) - } - -sz_69: - { - b := b_69[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_37 = (*[37]byte)(b_69[32:]) - } - -sz_37: - { - b := b_37[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_5 = (*[5]byte)(b_37[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_5: - h += n - goto sz_5l - -sz_100: - { - b := b_100[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_68 = (*[68]byte)(b_100[32:]) - } - -sz_68: - { - b := b_68[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_36 = (*[36]byte)(b_68[32:]) - } - -sz_36: - { - b := b_36[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_4 = (*[4]byte)(b_36[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_4: - h += n - goto sz_4l - -sz_99: - { - b := b_99[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_67 = (*[67]byte)(b_99[32:]) - } - -sz_67: - { - b := b_67[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_35 = (*[35]byte)(b_67[32:]) - } - -sz_35: - { - b := b_35[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_3 = (*[3]byte)(b_35[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_3: - h += n - goto sz_3l - -sz_98: - { - b := b_98[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_66 = (*[66]byte)(b_98[32:]) - } - -sz_66: - { - b := b_66[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_34 = (*[34]byte)(b_66[32:]) - } - -sz_34: - { - b := b_34[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_2 = (*[2]byte)(b_34[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_2: - h += n - goto sz_2l - -sz_97: - { - b := b_97[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_65 = (*[65]byte)(b_97[32:]) - } - -sz_65: - { - b := b_65[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_33 = (*[33]byte)(b_65[32:]) - } - -sz_33: - { - b := b_33[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_1 = (*[1]byte)(b_33[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - -sz_1: - h += n - goto sz_1l - -sz_96: - { - b := b_96[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_64 = (*[64]byte)(b_96[32:]) - } - -sz_64: - { - b := b_64[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_32 = (*[32]byte)(b_64[32:]) - } - -sz_32: - { - b := b_32[:] - var load uint64 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v1 += load * prime2 - v1 = bits.RotateLeft64(v1, 31) - v1 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v2 += load * prime2 - v2 = bits.RotateLeft64(v2, 31) - v2 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v3 += load * prime2 - v3 = bits.RotateLeft64(v3, 31) - v3 *= prime1 - load = uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - b = b[8:] - v4 += load * prime2 - v4 = bits.RotateLeft64(v4, 31) - v4 *= prime1 - b_0 = (*[0]byte)(b_32[32:]) - } - - h = bits.RotateLeft64(v1, 1) + bits.RotateLeft64(v2, 7) + bits.RotateLeft64(v3, 12) + bits.RotateLeft64(v4, 18) - { - var temp uint64 - temp += v1 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v2 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v3 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - { - var temp uint64 - temp += v4 * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = h*prime1 + prime4 - } - - h += n - goto sz_0l - - // Theses are 8 bytes block trailing slides. -sz_31l: - { - b := b_31[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_23 = (*[23]byte)(b_31[8:]) - } - -sz_23l: - { - b := b_23[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_15 = (*[15]byte)(b_23[8:]) - } - -sz_15l: - { - b := b_15[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_7 = (*[7]byte)(b_15[8:]) - } - - goto sz_7l - -sz_30l: - { - b := b_30[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_22 = (*[22]byte)(b_30[8:]) - } - -sz_22l: - { - b := b_22[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_14 = (*[14]byte)(b_22[8:]) - } - -sz_14l: - { - b := b_14[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_6 = (*[6]byte)(b_14[8:]) - } - - goto sz_6l - -sz_29l: - { - b := b_29[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_21 = (*[21]byte)(b_29[8:]) - } - -sz_21l: - { - b := b_21[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_13 = (*[13]byte)(b_21[8:]) - } - -sz_13l: - { - b := b_13[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_5 = (*[5]byte)(b_13[8:]) - } - - goto sz_5l - -sz_28l: - { - b := b_28[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_20 = (*[20]byte)(b_28[8:]) - } - -sz_20l: - { - b := b_20[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_12 = (*[12]byte)(b_20[8:]) - } - -sz_12l: - { - b := b_12[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_4 = (*[4]byte)(b_12[8:]) - } - - goto sz_4l - -sz_27l: - { - b := b_27[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_19 = (*[19]byte)(b_27[8:]) - } - -sz_19l: - { - b := b_19[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_11 = (*[11]byte)(b_19[8:]) - } - -sz_11l: - { - b := b_11[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_3 = (*[3]byte)(b_11[8:]) - } - - goto sz_3l - -sz_26l: - { - b := b_26[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_18 = (*[18]byte)(b_26[8:]) - } - -sz_18l: - { - b := b_18[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_10 = (*[10]byte)(b_18[8:]) - } - -sz_10l: - { - b := b_10[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_2 = (*[2]byte)(b_10[8:]) - } - - goto sz_2l - -sz_25l: - { - b := b_25[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_17 = (*[17]byte)(b_25[8:]) - } - -sz_17l: - { - b := b_17[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_9 = (*[9]byte)(b_17[8:]) - } - -sz_9l: - { - b := b_9[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_1 = (*[1]byte)(b_9[8:]) - } - - goto sz_1l - -sz_24l: - { - b := b_24[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_16 = (*[16]byte)(b_24[8:]) - } - -sz_16l: - { - b := b_16[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_8 = (*[8]byte)(b_16[8:]) - } - -sz_8l: - { - b := b_8[:] - load := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 // Work around for go.dev/issue/68081. - var temp uint64 - temp += load * prime2 - temp = bits.RotateLeft64(temp, 31) - temp *= prime1 - h ^= temp - h = bits.RotateLeft64(h, 27)*prime1 + prime4 - b_0 = (*[0]byte)(b_8[8:]) - } - - goto sz_0l - - // Theses are the 4 bytes trailing slides. -sz_7l: - { - b := b_7[:] - load := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 // Work around for go.dev/issue/68081. - h ^= uint64(load) * prime1 - h = bits.RotateLeft64(h, 23)*prime2 + prime3 - b_3 = (*[3]byte)(b_7[4:]) - goto sz_3l - } - -sz_6l: - { - b := b_6[:] - load := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 // Work around for go.dev/issue/68081. - h ^= uint64(load) * prime1 - h = bits.RotateLeft64(h, 23)*prime2 + prime3 - b_2 = (*[2]byte)(b_6[4:]) - goto sz_2l - } - -sz_5l: - { - b := b_5[:] - load := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 // Work around for go.dev/issue/68081. - h ^= uint64(load) * prime1 - h = bits.RotateLeft64(h, 23)*prime2 + prime3 - b_1 = (*[1]byte)(b_5[4:]) - goto sz_1l - } - -sz_4l: - { - b := b_4[:] - load := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 // Work around for go.dev/issue/68081. - h ^= uint64(load) * prime1 - h = bits.RotateLeft64(h, 23)*prime2 + prime3 - b_0 = (*[0]byte)(b_4[4:]) - goto sz_0l - } - - // This is the 1 bytes trailing slide. -sz_3l: - h ^= uint64(b_3[0]) * prime5 - h = bits.RotateLeft64(h, 11) * prime1 - b_2 = (*[2]byte)(b_3[1:]) - -sz_2l: - h ^= uint64(b_2[0]) * prime5 - h = bits.RotateLeft64(h, 11) * prime1 - b_1 = (*[1]byte)(b_2[1:]) - -sz_1l: - h ^= uint64(b_1[0]) * prime5 - h = bits.RotateLeft64(h, 11) * prime1 - b_0 = (*[0]byte)(b_1[1:]) - - // Finally the terminator. -sz_0l: - _ = b_0 // this avoids a bunch of if i != 0 { in codegen and is optimized away. - - h ^= h >> 33 - h *= prime2 - h ^= h >> 29 - h *= prime3 - h ^= h >> 32 - - return h -} From 1bea64505206431e86ace12f6e2584136dc1c617 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Thu, 20 Jun 2024 16:08:16 +0200 Subject: [PATCH 16/16] gate avx512 behind go1.22 PCALIGN gives a ~12% performance improvement so we really want it, if you are using a previous version of go, too bad please upgrade. --- xxhash_asm_amd64.go | 4 ++-- xxhash_asm_amd64_old.go | 22 ++++++++++++++++++++++ xxhash_avx512_amd64.s | 3 ++- 3 files changed, 26 insertions(+), 3 deletions(-) create mode 100644 xxhash_asm_amd64_old.go diff --git a/xxhash_asm_amd64.go b/xxhash_asm_amd64.go index d594363..1ff7c47 100644 --- a/xxhash_asm_amd64.go +++ b/xxhash_asm_amd64.go @@ -1,5 +1,5 @@ -//go:build amd64 && !appengine && gc && !purego -// +build amd64,!appengine,gc,!purego +//go:build amd64 && !appengine && gc && !purego && go1.22 +// +build amd64,!appengine,gc,!purego,go1.22 package xxhash diff --git a/xxhash_asm_amd64_old.go b/xxhash_asm_amd64_old.go new file mode 100644 index 0000000..3da4816 --- /dev/null +++ b/xxhash_asm_amd64_old.go @@ -0,0 +1,22 @@ +//go:build amd64 && !appengine && gc && !purego && !go1.22 +// +build amd64,!appengine,gc,!purego,!go1.22 + +// The avx512 impl relies on PCALIGN. + +package xxhash + +// Sum64 computes the 64-bit xxHash digest of b with a zero seed. +func Sum64(b []byte) uint64 { + return sum64Scalar(b) +} + +//go:noescape +func sum64Scalar(b []byte) uint64 + +// extra is a first block before b, it may be nil then skip it. +func writeBlocks(d *Digest, extra *[32]byte, b []byte) { + return writeBlocksScalar(d, extra, b) +} + +//go:noescape +func writeBlocksScalar(d *Digest, extra *[32]byte, b []byte) diff --git a/xxhash_avx512_amd64.s b/xxhash_avx512_amd64.s index b740c32..0bbb86b 100644 --- a/xxhash_avx512_amd64.s +++ b/xxhash_avx512_amd64.s @@ -1,7 +1,8 @@ -//go:build !appengine && gc && !purego +//go:build !appengine && gc && !purego && go1.22 // +build !appengine // +build gc // +build !purego +// +build go1.22 #include "textflag.h"