Codebase list golang-github-minio-sha256-simd / 198d640
New upstream version 0.0~git20161015.0.f78567f Alexandre Viau 7 years ago
29 changed file(s) with 4948 addition(s) and 0 deletion(s). Raw diff Collapse all Expand all
0 sudo: required
1 dist: trusty
2 language: go
3
4 os:
5 - linux
6 - osx
7
8 osx_image: xcode7.2
9
10 go:
11 - 1.6
12 - 1.5
13
14 env:
15 - ARCH=x86_64
16 - ARCH=i686
17
18 script:
19 - diff -au <(gofmt -d .) <(printf "")
20 - go test -race -v ./...
0
1 Apache License
2 Version 2.0, January 2004
3 http://www.apache.org/licenses/
4
5 TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
6
7 1. Definitions.
8
9 "License" shall mean the terms and conditions for use, reproduction,
10 and distribution as defined by Sections 1 through 9 of this document.
11
12 "Licensor" shall mean the copyright owner or entity authorized by
13 the copyright owner that is granting the License.
14
15 "Legal Entity" shall mean the union of the acting entity and all
16 other entities that control, are controlled by, or are under common
17 control with that entity. For the purposes of this definition,
18 "control" means (i) the power, direct or indirect, to cause the
19 direction or management of such entity, whether by contract or
20 otherwise, or (ii) ownership of fifty percent (50%) or more of the
21 outstanding shares, or (iii) beneficial ownership of such entity.
22
23 "You" (or "Your") shall mean an individual or Legal Entity
24 exercising permissions granted by this License.
25
26 "Source" form shall mean the preferred form for making modifications,
27 including but not limited to software source code, documentation
28 source, and configuration files.
29
30 "Object" form shall mean any form resulting from mechanical
31 transformation or translation of a Source form, including but
32 not limited to compiled object code, generated documentation,
33 and conversions to other media types.
34
35 "Work" shall mean the work of authorship, whether in Source or
36 Object form, made available under the License, as indicated by a
37 copyright notice that is included in or attached to the work
38 (an example is provided in the Appendix below).
39
40 "Derivative Works" shall mean any work, whether in Source or Object
41 form, that is based on (or derived from) the Work and for which the
42 editorial revisions, annotations, elaborations, or other modifications
43 represent, as a whole, an original work of authorship. For the purposes
44 of this License, Derivative Works shall not include works that remain
45 separable from, or merely link (or bind by name) to the interfaces of,
46 the Work and Derivative Works thereof.
47
48 "Contribution" shall mean any work of authorship, including
49 the original version of the Work and any modifications or additions
50 to that Work or Derivative Works thereof, that is intentionally
51 submitted to Licensor for inclusion in the Work by the copyright owner
52 or by an individual or Legal Entity authorized to submit on behalf of
53 the copyright owner. For the purposes of this definition, "submitted"
54 means any form of electronic, verbal, or written communication sent
55 to the Licensor or its representatives, including but not limited to
56 communication on electronic mailing lists, source code control systems,
57 and issue tracking systems that are managed by, or on behalf of, the
58 Licensor for the purpose of discussing and improving the Work, but
59 excluding communication that is conspicuously marked or otherwise
60 designated in writing by the copyright owner as "Not a Contribution."
61
62 "Contributor" shall mean Licensor and any individual or Legal Entity
63 on behalf of whom a Contribution has been received by Licensor and
64 subsequently incorporated within the Work.
65
66 2. Grant of Copyright License. Subject to the terms and conditions of
67 this License, each Contributor hereby grants to You a perpetual,
68 worldwide, non-exclusive, no-charge, royalty-free, irrevocable
69 copyright license to reproduce, prepare Derivative Works of,
70 publicly display, publicly perform, sublicense, and distribute the
71 Work and such Derivative Works in Source or Object form.
72
73 3. Grant of Patent License. Subject to the terms and conditions of
74 this License, each Contributor hereby grants to You a perpetual,
75 worldwide, non-exclusive, no-charge, royalty-free, irrevocable
76 (except as stated in this section) patent license to make, have made,
77 use, offer to sell, sell, import, and otherwise transfer the Work,
78 where such license applies only to those patent claims licensable
79 by such Contributor that are necessarily infringed by their
80 Contribution(s) alone or by combination of their Contribution(s)
81 with the Work to which such Contribution(s) was submitted. If You
82 institute patent litigation against any entity (including a
83 cross-claim or counterclaim in a lawsuit) alleging that the Work
84 or a Contribution incorporated within the Work constitutes direct
85 or contributory patent infringement, then any patent licenses
86 granted to You under this License for that Work shall terminate
87 as of the date such litigation is filed.
88
89 4. Redistribution. You may reproduce and distribute copies of the
90 Work or Derivative Works thereof in any medium, with or without
91 modifications, and in Source or Object form, provided that You
92 meet the following conditions:
93
94 (a) You must give any other recipients of the Work or
95 Derivative Works a copy of this License; and
96
97 (b) You must cause any modified files to carry prominent notices
98 stating that You changed the files; and
99
100 (c) You must retain, in the Source form of any Derivative Works
101 that You distribute, all copyright, patent, trademark, and
102 attribution notices from the Source form of the Work,
103 excluding those notices that do not pertain to any part of
104 the Derivative Works; and
105
106 (d) If the Work includes a "NOTICE" text file as part of its
107 distribution, then any Derivative Works that You distribute must
108 include a readable copy of the attribution notices contained
109 within such NOTICE file, excluding those notices that do not
110 pertain to any part of the Derivative Works, in at least one
111 of the following places: within a NOTICE text file distributed
112 as part of the Derivative Works; within the Source form or
113 documentation, if provided along with the Derivative Works; or,
114 within a display generated by the Derivative Works, if and
115 wherever such third-party notices normally appear. The contents
116 of the NOTICE file are for informational purposes only and
117 do not modify the License. You may add Your own attribution
118 notices within Derivative Works that You distribute, alongside
119 or as an addendum to the NOTICE text from the Work, provided
120 that such additional attribution notices cannot be construed
121 as modifying the License.
122
123 You may add Your own copyright statement to Your modifications and
124 may provide additional or different license terms and conditions
125 for use, reproduction, or distribution of Your modifications, or
126 for any such Derivative Works as a whole, provided Your use,
127 reproduction, and distribution of the Work otherwise complies with
128 the conditions stated in this License.
129
130 5. Submission of Contributions. Unless You explicitly state otherwise,
131 any Contribution intentionally submitted for inclusion in the Work
132 by You to the Licensor shall be under the terms and conditions of
133 this License, without any additional terms or conditions.
134 Notwithstanding the above, nothing herein shall supersede or modify
135 the terms of any separate license agreement you may have executed
136 with Licensor regarding such Contributions.
137
138 6. Trademarks. This License does not grant permission to use the trade
139 names, trademarks, service marks, or product names of the Licensor,
140 except as required for reasonable and customary use in describing the
141 origin of the Work and reproducing the content of the NOTICE file.
142
143 7. Disclaimer of Warranty. Unless required by applicable law or
144 agreed to in writing, Licensor provides the Work (and each
145 Contributor provides its Contributions) on an "AS IS" BASIS,
146 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 implied, including, without limitation, any warranties or conditions
148 of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 PARTICULAR PURPOSE. You are solely responsible for determining the
150 appropriateness of using or redistributing the Work and assume any
151 risks associated with Your exercise of permissions under this License.
152
153 8. Limitation of Liability. In no event and under no legal theory,
154 whether in tort (including negligence), contract, or otherwise,
155 unless required by applicable law (such as deliberate and grossly
156 negligent acts) or agreed to in writing, shall any Contributor be
157 liable to You for damages, including any direct, indirect, special,
158 incidental, or consequential damages of any character arising as a
159 result of this License or out of the use or inability to use the
160 Work (including but not limited to damages for loss of goodwill,
161 work stoppage, computer failure or malfunction, or any and all
162 other commercial damages or losses), even if such Contributor
163 has been advised of the possibility of such damages.
164
165 9. Accepting Warranty or Additional Liability. While redistributing
166 the Work or Derivative Works thereof, You may choose to offer,
167 and charge a fee for, acceptance of support, warranty, indemnity,
168 or other liability obligations and/or rights consistent with this
169 License. However, in accepting such obligations, You may act only
170 on Your own behalf and on Your sole responsibility, not on behalf
171 of any other Contributor, and only if You agree to indemnify,
172 defend, and hold each Contributor harmless for any liability
173 incurred by, or claims asserted against, such Contributor by reason
174 of your accepting any such warranty or additional liability.
175
176 END OF TERMS AND CONDITIONS
177
178 APPENDIX: How to apply the Apache License to your work.
179
180 To apply the Apache License to your work, attach the following
181 boilerplate notice, with the fields enclosed by brackets "[]"
182 replaced with your own identifying information. (Don't include
183 the brackets!) The text should be enclosed in the appropriate
184 comment syntax for the file format. We also recommend that a
185 file or class name and description of purpose be included on the
186 same "printed page" as the copyright notice for easier
187 identification within third-party archives.
188
189 Copyright [yyyy] [name of copyright owner]
190
191 Licensed under the Apache License, Version 2.0 (the "License");
192 you may not use this file except in compliance with the License.
193 You may obtain a copy of the License at
194
195 http://www.apache.org/licenses/LICENSE-2.0
196
197 Unless required by applicable law or agreed to in writing, software
198 distributed under the License is distributed on an "AS IS" BASIS,
199 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 See the License for the specific language governing permissions and
201 limitations under the License.
0 # sha256-simd
1
2 Accelerate SHA256 computations in pure Go for both Intel (AVX2, AVX, SSE) as well as ARM (arm64) platforms.
3
4 ## Introduction
5
6 This package is designed as a drop-in replacement for `crypto/sha256`. For Intel CPUs it has three flavors for AVX2, AVX and SSE whereby the fastest method is automatically chosen depending on CPU capabilities. For ARM CPUs with the Cryptography Extensions advantage is taken of the SHA2 instructions resulting in a massive performance improvement.
7
8 This package uses Golang assembly and as such does not depend on cgo. The Intel versions are based on the implementations as described in "Fast SHA-256 Implementations on Intel Architecture Processors" by J. Guilford et al.
9
10 ## Performance
11
12 Below is the speed in MB/s for a single core (ranked fast to slow) as well as the factor of improvement over `crypto/sha256` (when applicable).
13
14 | Processor | Package | Speed | Improvement |
15 | --------------------------------- | ---------------------------- | -----------:| -----------:|
16 | 1.2 GHz ARM Cortex-A53 | minio/sha256-simd (ARM64) | 638.2 MB/s | 105x |
17 | 2.4 GHz Intel Xeon CPU E5-2620 v3 | minio/sha256-simd (AVX2) (*) | 355.0 MB/s | 1.88x |
18 | 2.4 GHz Intel Xeon CPU E5-2620 v3 | minio/sha256-simd (AVX) | 306.0 MB/s | 1.62x |
19 | 2.4 GHz Intel Xeon CPU E5-2620 v3 | minio/sha256-simd (SSE) | 298.7 MB/s | 1.58x |
20 | 2.4 GHz Intel Xeon CPU E5-2620 v3 | crypto/sha256 | 189.2 MB/s | |
21 | 1.2 GHz ARM Cortex-A53 | crypto/sha256 | 6.1 MB/s | |
22
23 (*) Measured with the "unrolled"/"demacro-ed" AVX2 version. Due to some Golang assembly restrictions the AVX2 version that uses `defines` loses about 15% performance. The optimized version is contained in the git history so for maximum speed you want to do this after getting: `git cat-file blob 586b6e > sha256blockAvx2_amd64.s` (or vendor it for your project; see [here](https://github.com/minio/sha256-simd/blob/13b11bdf9b0580a756a111492d2ae382bab7ec79/sha256blockAvx2_amd64.s) to view it in its full glory).
24
25 See further down for detailed performance.
26
27 ## Comparison to other hashing techniques
28
29 As measured on Intel Xeon (same as above) with AVX2 version:
30
31 | Method | Package | Speed |
32 | ------- | -------------------| --------:|
33 | BLAKE2B | [minio/blake2b-simd](https://github.com/minio/blake2b-simd) | 851 MB/s |
34 | MD5 | crypto/md5 | 607 MB/s |
35 | SHA1 | crypto/sha1 | 522 MB/s |
36 | SHA256 | minio/sha256-simd | 355 MB/s |
37 | SHA512 | crypto/sha512 | 306 MB/s |
38
39 asm2plan9s
40 ----------
41
42 In order to be able to work more easily with AVX2/AVX instructions, a separate tool was developed to convert AVX2/AVX instructions into the corresponding BYTE sequence as accepted by Go assembly. See [asm2plan9s](https://github.com/minio/asm2plan9s) for more information.
43
44 Why and benefits
45 ----------------
46
47 One of the most performance sensitive parts of [Minio](https://minio.io) server (object storage [server](https://github.com/minio/minio) compatible with Amazon S3) is related to SHA256 hash sums calculations. For instance during multi part uploads each part that is uploaded needs to be verified for data integrity by the server. Likewise in order to generated pre-signed URLs check sums must be calculated to ensure their validity.
48
49 Other applications that can benefit from enhanced SHA256 performance are deduplication in storage systems, intrusion detection, version control systems, integrity checking, etc.
50
51 ARM SHA Extensions
52 ------------------
53
54 The 64-bit ARMv8 core has introduced new instructions for SHA1 and SHA2 acceleration as part of the [Cryptography Extensions](http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0501f/CHDFJBCJ.html). Below you can see a small excerpt highlighting one of the rounds as is done for the SHA256 calculation process (for full code see [sha256block_arm64.s](https://github.com/minio/sha256-simd/blob/master/sha256block_arm64.s)).
55
56 ```
57 sha256h q2, q3, v9.4s
58 sha256h2 q3, q4, v9.4s
59 sha256su0 v5.4s, v6.4s
60 rev32 v8.16b, v8.16b
61 add v9.4s, v7.4s, v18.4s
62 mov v4.16b, v2.16b
63 sha256h q2, q3, v10.4s
64 sha256h2 q3, q4, v10.4s
65 sha256su0 v6.4s, v7.4s
66 sha256su1 v5.4s, v7.4s, v8.4s
67 ```
68
69 Detailed benchmarks
70 -------------------
71
72 ### ARM64
73
74 Benchmarks generated on a 1.2 Ghz Quad-Core ARM Cortex A53 equipped [Pine64](https://www.pine64.com/).
75
76 ```
77 minio@minio-arm:~/gopath/src/github.com/sha256-simd$ benchcmp golang.txt arm64.txt
78 benchmark old ns/op new ns/op delta
79 BenchmarkHash8Bytes-4 11836 1403 -88.15%
80 BenchmarkHash1K-4 181143 3138 -98.27%
81 BenchmarkHash8K-4 1365652 14356 -98.95%
82 BenchmarkHash1M-4 173192200 1642954 -99.05%
83
84 benchmark old MB/s new MB/s speedup
85 BenchmarkHash8Bytes-4 0.68 5.70 8.38x
86 BenchmarkHash1K-4 5.65 326.30 57.75x
87 BenchmarkHash8K-4 6.00 570.63 95.11x
88 BenchmarkHash1M-4 6.05 638.23 105.49x
89 ```
90
91 Example performance metrics were generated on Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz - 6 physical cores, 12 logical cores running Ubuntu GNU/Linux with kernel version 4.4.0-24-generic (vanilla with no optimizations).
92
93 ### AVX2
94
95 ```
96 $ benchcmp go.txt avx2.txt
97 benchmark old ns/op new ns/op delta
98 BenchmarkHash8Bytes-12 446 364 -18.39%
99 BenchmarkHash1K-12 5919 3279 -44.60%
100 BenchmarkHash8K-12 43791 23655 -45.98%
101 BenchmarkHash1M-12 5544989 2969305 -46.45%
102
103 benchmark old MB/s new MB/s speedup
104 BenchmarkHash8Bytes-12 17.93 21.96 1.22x
105 BenchmarkHash1K-12 172.98 312.27 1.81x
106 BenchmarkHash8K-12 187.07 346.31 1.85x
107 BenchmarkHash1M-12 189.10 353.14 1.87x
108 ```
109
110 ### AVX
111
112 ```
113 $ benchcmp go.txt avx.txt
114 benchmark old ns/op new ns/op delta
115 BenchmarkHash8Bytes-12 446 346 -22.42%
116 BenchmarkHash1K-12 5919 3701 -37.47%
117 BenchmarkHash8K-12 43791 27222 -37.84%
118 BenchmarkHash1M-12 5544989 3426938 -38.20%
119
120 benchmark old MB/s new MB/s speedup
121 BenchmarkHash8Bytes-12 17.93 23.06 1.29x
122 BenchmarkHash1K-12 172.98 276.64 1.60x
123 BenchmarkHash8K-12 187.07 300.93 1.61x
124 BenchmarkHash1M-12 189.10 305.98 1.62x
125 ```
126
127 ### SSE
128
129 ```
130 $ benchcmp go.txt sse.txt
131 benchmark old ns/op new ns/op delta
132 BenchmarkHash8Bytes-12 446 362 -18.83%
133 BenchmarkHash1K-12 5919 3751 -36.63%
134 BenchmarkHash8K-12 43791 27396 -37.44%
135 BenchmarkHash1M-12 5544989 3444623 -37.88%
136
137 benchmark old MB/s new MB/s speedup
138 BenchmarkHash8Bytes-12 17.93 22.05 1.23x
139 BenchmarkHash1K-12 172.98 272.92 1.58x
140 BenchmarkHash8K-12 187.07 299.01 1.60x
141 BenchmarkHash1M-12 189.10 304.41 1.61x
142 ```
143
144 License
145 -------
146
147 Released under the Apache License v2.0. You can find the complete text in the file LICENSE.
148
149 Contributing
150 ------------
151
152 Contributions are welcome, please send PRs for any enhancements.
0 # version format
1 version: "{build}"
2
3 # Operating system (build VM template)
4 os: Windows Server 2012 R2
5
6 # Platform.
7 platform: x64
8
9 clone_folder: c:\gopath\src\github.com\minio\sha256-simd
10
11 # environment variables
12 environment:
13 GOPATH: c:\gopath
14 GO15VENDOREXPERIMENT: 1
15
16 # scripts that run after cloning repository
17 install:
18 - set PATH=%GOPATH%\bin;c:\go\bin;%PATH%
19 - go version
20 - go env
21
22 # to run your custom scripts instead of automatic MSBuild
23 build_script:
24 - go test .
25 - go test -race .
26
27 # to disable automatic tests
28 test: off
29
30 # to disable deployment
31 deploy: off
0 // Minio Cloud Storage, (C) 2016 Minio, Inc.
1 //
2 // Licensed under the Apache License, Version 2.0 (the "License");
3 // you may not use this file except in compliance with the License.
4 // You may obtain a copy of the License at
5 //
6 // http://www.apache.org/licenses/LICENSE-2.0
7 //
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
13 //
14
15 package sha256
16
17 // True when SIMD instructions are available.
18 var avx2 = haveAVX2()
19 var avx = haveAVX()
20 var ssse3 = haveSSSE3()
21 var armSha = haveArmSha()
22
23 // haveAVX returns true when there is AVX support
24 func haveAVX() bool {
25 _, _, c, _ := cpuid(1)
26
27 // Check XGETBV, OXSAVE and AVX bits
28 if c&(1<<26) != 0 && c&(1<<27) != 0 && c&(1<<28) != 0 {
29 // Check for OS support
30 eax, _ := xgetbv(0)
31 return (eax & 0x6) == 0x6
32 }
33 return false
34 }
35
36 // haveAVX2 returns true when there is AVX2 support
37 func haveAVX2() bool {
38 mfi, _, _, _ := cpuid(0)
39
40 // Check AVX2, AVX2 requires OS support, but BMI1/2 don't.
41 if mfi >= 7 && haveAVX() {
42 _, ebx, _, _ := cpuidex(7, 0)
43 return (ebx & 0x00000020) != 0
44 }
45 return false
46 }
47
48 // haveSSSE3 returns true when there is SSSE3 support
49 func haveSSSE3() bool {
50
51 _, _, c, _ := cpuid(1)
52
53 return (c & 0x00000200) != 0
54 }
0 // Minio Cloud Storage, (C) 2016 Minio, Inc.
1 //
2 // Licensed under the Apache License, Version 2.0 (the "License");
3 // you may not use this file except in compliance with the License.
4 // You may obtain a copy of the License at
5 //
6 // http://www.apache.org/licenses/LICENSE-2.0
7 //
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
13 //
14
15 package sha256
16
17 func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
18 func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
19 func xgetbv(index uint32) (eax, edx uint32)
20
21 func haveArmSha() bool {
22 return false
23 }
0 // The MIT License (MIT)
1 //
2 // Copyright (c) 2015 Klaus Post
3 //
4 // Permission is hereby granted, free of charge, to any person obtaining a copy
5 // of this software and associated documentation files (the "Software"), to deal
6 // in the Software without restriction, including without limitation the rights
7 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 // copies of the Software, and to permit persons to whom the Software is
9 // furnished to do so, subject to the following conditions:
10 //
11 // The above copyright notice and this permission notice shall be included in all
12 // copies or substantial portions of the Software.
13 //
14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 // SOFTWARE.
21
22 // +build 386,!gccgo
23
24 // func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
25 TEXT ·cpuid(SB), 7, $0
26 XORL CX, CX
27 MOVL op+0(FP), AX
28 CPUID
29 MOVL AX, eax+4(FP)
30 MOVL BX, ebx+8(FP)
31 MOVL CX, ecx+12(FP)
32 MOVL DX, edx+16(FP)
33 RET
34
35 // func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
36 TEXT ·cpuidex(SB), 7, $0
37 MOVL op+0(FP), AX
38 MOVL op2+4(FP), CX
39 CPUID
40 MOVL AX, eax+8(FP)
41 MOVL BX, ebx+12(FP)
42 MOVL CX, ecx+16(FP)
43 MOVL DX, edx+20(FP)
44 RET
45
46 // func xgetbv(index uint32) (eax, edx uint32)
47 TEXT ·xgetbv(SB), 7, $0
48 MOVL index+0(FP), CX
49 BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
50 MOVL AX, eax+4(FP)
51 MOVL DX, edx+8(FP)
52 RET
0 // Minio Cloud Storage, (C) 2016 Minio, Inc.
1 //
2 // Licensed under the Apache License, Version 2.0 (the "License");
3 // you may not use this file except in compliance with the License.
4 // You may obtain a copy of the License at
5 //
6 // http://www.apache.org/licenses/LICENSE-2.0
7 //
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
13 //
14
15 package sha256
16
17 func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
18 func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
19 func xgetbv(index uint32) (eax, edx uint32)
20
21 func haveArmSha() bool {
22 return false
23 }
0 // The MIT License (MIT)
1 //
2 // Copyright (c) 2015 Klaus Post
3 //
4 // Permission is hereby granted, free of charge, to any person obtaining a copy
5 // of this software and associated documentation files (the "Software"), to deal
6 // in the Software without restriction, including without limitation the rights
7 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 // copies of the Software, and to permit persons to whom the Software is
9 // furnished to do so, subject to the following conditions:
10 //
11 // The above copyright notice and this permission notice shall be included in all
12 // copies or substantial portions of the Software.
13 //
14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 // SOFTWARE.
21
22 // +build amd64,!gccgo
23
24 // func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
25 TEXT ·cpuid(SB), 7, $0
26 XORQ CX, CX
27 MOVL op+0(FP), AX
28 CPUID
29 MOVL AX, eax+8(FP)
30 MOVL BX, ebx+12(FP)
31 MOVL CX, ecx+16(FP)
32 MOVL DX, edx+20(FP)
33 RET
34
35
36 // func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
37 TEXT ·cpuidex(SB), 7, $0
38 MOVL op+0(FP), AX
39 MOVL op2+4(FP), CX
40 CPUID
41 MOVL AX, eax+8(FP)
42 MOVL BX, ebx+12(FP)
43 MOVL CX, ecx+16(FP)
44 MOVL DX, edx+20(FP)
45 RET
46
47 // func xgetbv(index uint32) (eax, edx uint32)
48 TEXT ·xgetbv(SB), 7, $0
49 MOVL index+0(FP), CX
50 BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
51 MOVL AX, eax+8(FP)
52 MOVL DX, edx+12(FP)
53 RET
0 // Minio Cloud Storage, (C) 2016 Minio, Inc.
1 //
2 // Licensed under the Apache License, Version 2.0 (the "License");
3 // you may not use this file except in compliance with the License.
4 // You may obtain a copy of the License at
5 //
6 // http://www.apache.org/licenses/LICENSE-2.0
7 //
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
13 //
14
15 package sha256
16
17 func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
18 return 0, 0, 0, 0
19 }
20
21 func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
22 return 0, 0, 0, 0
23 }
24
25 func xgetbv(index uint32) (eax, edx uint32) {
26 return 0, 0
27 }
28
29 func haveArmSha() bool {
30 // TODO: Implement feature detection for ARM
31 return true
32 }
0 // Minio Cloud Storage, (C) 2016 Minio, Inc.
1 //
2 // Licensed under the Apache License, Version 2.0 (the "License");
3 // you may not use this file except in compliance with the License.
4 // You may obtain a copy of the License at
5 //
6 // http://www.apache.org/licenses/LICENSE-2.0
7 //
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
13 //
14
15 package sha256
16
17 func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
18 return 0, 0, 0, 0
19 }
20
21 func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
22 return 0, 0, 0, 0
23 }
24
25 func xgetbv(index uint32) (eax, edx uint32) {
26 return 0, 0
27 }
28
29 func haveArmSha() bool {
30 // TODO: Implement feature detection for ARM
31 return true
32 }
0 // Minio Cloud Storage, (C) 2016 Minio, Inc.
1 //
2 // Licensed under the Apache License, Version 2.0 (the "License");
3 // you may not use this file except in compliance with the License.
4 // You may obtain a copy of the License at
5 //
6 // http://www.apache.org/licenses/LICENSE-2.0
7 //
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
13 //
14
15 package sha256
16
17 func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
18 return 0, 0, 0, 0
19 }
20
21 func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
22 return 0, 0, 0, 0
23 }
24
25 func xgetbv(index uint32) (eax, edx uint32) {
26 return 0, 0
27 }
28
29 func haveArmSha() bool {
30 return false
31 }
0 // Minio Cloud Storage, (C) 2016 Minio, Inc.
1 //
2 // Licensed under the Apache License, Version 2.0 (the "License");
3 // you may not use this file except in compliance with the License.
4 // You may obtain a copy of the License at
5 //
6 // http://www.apache.org/licenses/LICENSE-2.0
7 //
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
13 //
14
15 package sha256
16
17 func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
18 return 0, 0, 0, 0
19 }
20
21 func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
22 return 0, 0, 0, 0
23 }
24
25 func xgetbv(index uint32) (eax, edx uint32) {
26 return 0, 0
27 }
28
29 func haveArmSha() bool {
30 return false
31 }
0 /*
1 * Minio Cloud Storage, (C) 2016 Minio, Inc.
2 *
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 package sha256
17
18 import (
19 "crypto/sha256"
20 "hash"
21 "runtime"
22 )
23
24 // Size - The size of a SHA256 checksum in bytes.
25 const Size = 32
26
27 // BlockSize - The blocksize of SHA256 in bytes.
28 const BlockSize = 64
29
30 const (
31 chunk = 64
32 init0 = 0x6A09E667
33 init1 = 0xBB67AE85
34 init2 = 0x3C6EF372
35 init3 = 0xA54FF53A
36 init4 = 0x510E527F
37 init5 = 0x9B05688C
38 init6 = 0x1F83D9AB
39 init7 = 0x5BE0CD19
40 )
41
42 // digest represents the partial evaluation of a checksum.
43 type digest struct {
44 h [8]uint32
45 x [chunk]byte
46 nx int
47 len uint64
48 }
49
50 // Reset digest back to default
51 func (d *digest) Reset() {
52 d.h[0] = init0
53 d.h[1] = init1
54 d.h[2] = init2
55 d.h[3] = init3
56 d.h[4] = init4
57 d.h[5] = init5
58 d.h[6] = init6
59 d.h[7] = init7
60 d.nx = 0
61 d.len = 0
62 }
63
64 func block(dig *digest, p []byte) {
65 is386bit := runtime.GOARCH == "386"
66 isARM := runtime.GOARCH == "arm"
67 if is386bit || isARM {
68 blockGeneric(dig, p)
69 }
70 switch !is386bit && !isARM {
71 case avx2:
72 blockAvx2Go(dig, p)
73 case avx:
74 blockAvxGo(dig, p)
75 case ssse3:
76 blockSsseGo(dig, p)
77 case armSha:
78 blockArmGo(dig, p)
79 default:
80 blockGeneric(dig, p)
81 }
82 }
83
84 // New returns a new hash.Hash computing the SHA256 checksum.
85 func New() hash.Hash {
86 if avx2 || avx || ssse3 || armSha {
87 d := new(digest)
88 d.Reset()
89 return d
90 }
91 // default back to the standard golang implementation
92 return sha256.New()
93 }
94
95 // Sum256 - single caller sha256 helper
96 func Sum256(data []byte) [Size]byte {
97 var d digest
98 d.Reset()
99 d.Write(data)
100 return d.checkSum()
101 }
102
103 // Return size of checksum
104 func (d *digest) Size() int { return Size }
105
106 // Return blocksize of checksum
107 func (d *digest) BlockSize() int { return BlockSize }
108
109 // Write to digest
110 func (d *digest) Write(p []byte) (nn int, err error) {
111 nn = len(p)
112 d.len += uint64(nn)
113 if d.nx > 0 {
114 n := copy(d.x[d.nx:], p)
115 d.nx += n
116 if d.nx == chunk {
117 block(d, d.x[:])
118 d.nx = 0
119 }
120 p = p[n:]
121 }
122 if len(p) >= chunk {
123 n := len(p) &^ (chunk - 1)
124 block(d, p[:n])
125 p = p[n:]
126 }
127 if len(p) > 0 {
128 d.nx = copy(d.x[:], p)
129 }
130 return
131 }
132
133 // Return sha256 sum in bytes
134 func (d *digest) Sum(in []byte) []byte {
135 // Make a copy of d0 so that caller can keep writing and summing.
136 d0 := *d
137 hash := d0.checkSum()
138 return append(in, hash[:]...)
139 }
140
141 // Intermediate checksum function
142 func (d *digest) checkSum() [Size]byte {
143 len := d.len
144 // Padding. Add a 1 bit and 0 bits until 56 bytes mod 64.
145 var tmp [64]byte
146 tmp[0] = 0x80
147 if len%64 < 56 {
148 d.Write(tmp[0 : 56-len%64])
149 } else {
150 d.Write(tmp[0 : 64+56-len%64])
151 }
152
153 // Length in bits.
154 len <<= 3
155 for i := uint(0); i < 8; i++ {
156 tmp[i] = byte(len >> (56 - 8*i))
157 }
158 d.Write(tmp[0:8])
159
160 if d.nx != 0 {
161 panic("d.nx != 0")
162 }
163
164 h := d.h[:]
165
166 var digest [Size]byte
167 for i, s := range h {
168 digest[i*4] = byte(s >> 24)
169 digest[i*4+1] = byte(s >> 16)
170 digest[i*4+2] = byte(s >> 8)
171 digest[i*4+3] = byte(s)
172 }
173
174 return digest
175 }
0 /*
1 * Minio Cloud Storage, (C) 2016 Minio, Inc.
2 *
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 // Copyright (c) 2009 The Go Authors. All rights reserved.
17 //
18 // Redistribution and use in source and binary forms, with or without
19 // modification, are permitted provided that the following conditions are
20 // met:
21 //
22 // * Redistributions of source code must retain the above copyright
23 // notice, this list of conditions and the following disclaimer.
24 // * Redistributions in binary form must reproduce the above
25 // copyright notice, this list of conditions and the following disclaimer
26 // in the documentation and/or other materials provided with the
27 // distribution.
28 // * Neither the name of Google Inc. nor the names of its
29 // contributors may be used to endorse or promote products derived from
30 // this software without specific prior written permission.
31 //
32 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
35 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
37 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
38 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
39 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
40 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
41 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
42 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
43
44 // Using this part of Minio codebase under the license
45 // Apache License Version 2.0 with modifications
46
47 // SHA256 hash algorithm. See FIPS 180-2.
48
49 package sha256
50
51 import (
52 "encoding/hex"
53 "fmt"
54 "testing"
55 )
56
57 type sha256Test struct {
58 out [32]byte
59 in string
60 }
61
62 var golden = []sha256Test{
63 {[32]byte{(1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
64 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
65 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
66 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
67 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
68 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
69 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
70 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
71 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
72 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
73 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
74 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
75 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
76 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
77 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
78 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
79 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
80 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
81 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
82 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
83 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
84 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
85 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
86 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
87 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
88 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
89 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
90 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
91 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
92 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
93 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
94 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
95 ""},
96 {[32]byte{(0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
97 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
98 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
99 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
100 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
101 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
102 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
103 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
104 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
105 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
106 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
107 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
108 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
109 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
110 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
111 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
112 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
113 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
114 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
115 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
116 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
117 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
118 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
119 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
120 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
121 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
122 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
123 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
124 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
125 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
126 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
127 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128)},
128 "a"},
129 {[32]byte{(1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
130 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
131 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
132 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
133 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
134 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
135 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
136 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
137 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
138 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
139 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
140 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
141 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
142 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
143 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
144 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
145 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
146 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
147 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
148 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
149 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
150 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
151 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
152 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
153 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
154 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
155 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
156 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
157 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
158 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
159 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
160 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128)},
161 "ab"},
162 {[32]byte{(0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
163 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
164 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
165 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
166 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
167 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
168 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
169 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
170 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
171 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
172 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
173 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
174 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
175 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
176 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
177 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
178 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
179 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
180 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
181 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
182 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
183 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
184 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
185 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
186 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
187 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
188 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
189 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
190 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
191 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
192 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
193 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128)},
194 "abc"},
195 {[32]byte{(0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
196 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
197 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
198 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
199 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
200 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
201 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
202 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
203 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
204 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
205 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
206 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
207 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
208 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
209 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
210 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
211 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
212 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
213 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
214 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
215 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
216 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
217 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
218 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
219 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
220 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
221 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
222 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
223 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
224 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
225 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
226 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128)},
227 "abc"},
228 {[32]byte{(0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
229 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
230 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
231 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
232 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
233 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
234 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
235 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
236 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
237 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
238 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
239 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
240 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
241 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
242 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
243 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
244 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
245 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
246 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
247 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
248 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
249 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
250 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
251 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
252 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
253 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
254 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
255 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
256 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
257 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
258 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
259 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128)},
260 "abcd"},
261 {[32]byte{(0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
262 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
263 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
264 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
265 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
266 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
267 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
268 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
269 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
270 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
271 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
272 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
273 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
274 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
275 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
276 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
277 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
278 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
279 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
280 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
281 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
282 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
283 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
284 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
285 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
286 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
287 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
288 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
289 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
290 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
291 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
292 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128)},
293 "abcde"},
294 {[32]byte{(0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
295 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
296 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
297 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
298 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
299 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
300 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
301 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
302 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
303 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
304 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
305 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
306 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
307 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
308 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
309 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
310 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
311 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
312 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
313 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
314 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
315 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
316 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
317 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
318 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
319 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
320 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
321 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
322 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
323 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
324 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
325 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128)},
326 "abcdef"},
327 {[32]byte{(1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
328 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
329 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
330 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
331 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
332 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
333 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
334 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
335 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
336 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
337 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
338 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
339 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
340 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
341 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
342 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
343 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
344 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
345 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
346 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
347 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
348 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
349 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
350 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
351 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
352 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
353 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
354 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
355 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
356 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
357 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
358 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128)},
359 "abcdefg"},
360 {[32]byte{(0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
361 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
362 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
363 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
364 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
365 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
366 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
367 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
368 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
369 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
370 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
371 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
372 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
373 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
374 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
375 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
376 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
377 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
378 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
379 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
380 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
381 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
382 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
383 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
384 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
385 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
386 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
387 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
388 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
389 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
390 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
391 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128)},
392 "abcdefgh"},
393 {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
394 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
395 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
396 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
397 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
398 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
399 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
400 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
401 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
402 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
403 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
404 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
405 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
406 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
407 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
408 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
409 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
410 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
411 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
412 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
413 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
414 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
415 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
416 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
417 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
418 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
419 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
420 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
421 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
422 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
423 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
424 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128)},
425 "abcdefghi"},
426 {[32]byte{(0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
427 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
428 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
429 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
430 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
431 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
432 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
433 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
434 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
435 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
436 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
437 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
438 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
439 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
440 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
441 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
442 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
443 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
444 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
445 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
446 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
447 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
448 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
449 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
450 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
451 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
452 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
453 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
454 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
455 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
456 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
457 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128)},
458 "abcdefghij"},
459 {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
460 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
461 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
462 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
463 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
464 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
465 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
466 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
467 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
468 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
469 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
470 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
471 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
472 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
473 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
474 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
475 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
476 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
477 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
478 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
479 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
480 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
481 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
482 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
483 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
484 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
485 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
486 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
487 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
488 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
489 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
490 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
491 "Discard medicine more than two years old."},
492 {[32]byte{(1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
493 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
494 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
495 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
496 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
497 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
498 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
499 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
500 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
501 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
502 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
503 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
504 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
505 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
506 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
507 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
508 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
509 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
510 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
511 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
512 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
513 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
514 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
515 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
516 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
517 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
518 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
519 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
520 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
521 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
522 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
523 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
524 "He who has a shady past knows that nice guys finish last."},
525 {[32]byte{(0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
526 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
527 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
528 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
529 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
530 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
531 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
532 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
533 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
534 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
535 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
536 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
537 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
538 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
539 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
540 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
541 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
542 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
543 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
544 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
545 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
546 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
547 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
548 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
549 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
550 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
551 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
552 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
553 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
554 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
555 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
556 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128)},
557 "I wouldn't marry him with a ten foot pole."},
558 {[32]byte{(1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
559 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
560 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
561 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
562 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
563 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
564 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
565 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
566 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
567 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
568 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
569 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
570 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
571 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
572 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
573 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
574 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
575 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
576 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
577 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
578 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
579 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
580 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
581 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
582 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
583 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
584 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
585 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
586 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
587 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
588 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
589 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
590 "Free! Free!/A trip/to Mars/for 900/empty jars/Burma Shave"},
591 {[32]byte{(0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
592 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
593 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
594 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
595 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
596 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
597 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
598 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
599 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
600 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
601 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
602 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
603 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
604 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
605 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
606 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
607 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
608 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
609 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
610 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
611 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
612 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
613 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
614 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
615 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
616 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
617 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
618 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
619 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
620 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
621 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
622 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128)},
623 "The days of the digital watch are numbered. -Tom Stoppard"},
624 {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
625 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
626 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
627 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
628 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
629 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
630 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
631 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
632 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
633 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
634 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
635 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
636 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
637 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
638 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
639 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
640 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
641 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
642 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
643 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
644 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
645 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
646 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
647 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
648 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
649 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
650 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
651 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
652 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
653 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
654 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
655 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
656 "Nepal premier won't resign."},
657 {[32]byte{(1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
658 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
659 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
660 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
661 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
662 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
663 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
664 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
665 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
666 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
667 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
668 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
669 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
670 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
671 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
672 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
673 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
674 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
675 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
676 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
677 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
678 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
679 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
680 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
681 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
682 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
683 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
684 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
685 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
686 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
687 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
688 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128)},
689 "For every action there is an equal and opposite government program."},
690 {[32]byte{(0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
691 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
692 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
693 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
694 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
695 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
696 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
697 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
698 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
699 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
700 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
701 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
702 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
703 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
704 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
705 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
706 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
707 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
708 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
709 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
710 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
711 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
712 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
713 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
714 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
715 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
716 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
717 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
718 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
719 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
720 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
721 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
722 "His money is twice tainted: 'taint yours and 'taint mine."},
723 {[32]byte{(0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
724 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
725 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
726 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
727 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
728 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
729 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
730 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
731 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
732 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
733 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
734 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
735 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
736 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
737 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
738 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
739 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
740 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
741 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
742 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
743 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
744 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
745 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
746 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
747 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
748 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
749 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
750 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
751 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
752 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
753 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
754 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
755 "There is no reason for any individual to have a computer in their home. -Ken Olsen, 1977"},
756 {[32]byte{(1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
757 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
758 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
759 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
760 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
761 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
762 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
763 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
764 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
765 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
766 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
767 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
768 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
769 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
770 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
771 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
772 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
773 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
774 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
775 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
776 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
777 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
778 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
779 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
780 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
781 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
782 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
783 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
784 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
785 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
786 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
787 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
788 "It's a tiny change to the code and not completely disgusting. - Bob Manchek"},
789 {[32]byte{(1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
790 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
791 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
792 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
793 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
794 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
795 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
796 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
797 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
798 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
799 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
800 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
801 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
802 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
803 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
804 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
805 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
806 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
807 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
808 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
809 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
810 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
811 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
812 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
813 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
814 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
815 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
816 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
817 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
818 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
819 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
820 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128)},
821 "size: a.out: bad magic"},
822 {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
823 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
824 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
825 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
826 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
827 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
828 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
829 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
830 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
831 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
832 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
833 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
834 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
835 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
836 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
837 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
838 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
839 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
840 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
841 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
842 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
843 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
844 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
845 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
846 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
847 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
848 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
849 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
850 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
851 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
852 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
853 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128)},
854 "The major problem is with sendmail. -Mark Horton"},
855 {[32]byte{(0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
856 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
857 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
858 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
859 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
860 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
861 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
862 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
863 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
864 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
865 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
866 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
867 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
868 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
869 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
870 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
871 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
872 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
873 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
874 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
875 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
876 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
877 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
878 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
879 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
880 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
881 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
882 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
883 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
884 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
885 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
886 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
887 "Give me a rock, paper and scissors and I will move the world. CCFestoon"},
888 {[32]byte{(0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
889 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
890 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
891 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
892 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
893 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
894 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
895 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
896 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
897 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
898 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
899 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
900 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
901 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
902 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
903 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
904 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
905 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
906 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
907 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
908 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
909 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
910 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
911 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
912 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
913 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
914 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
915 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
916 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
917 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
918 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
919 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
920 "If the enemy is within range, then so are you."},
921 {[32]byte{(0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
922 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
923 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
924 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
925 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
926 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
927 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
928 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
929 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
930 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
931 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
932 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
933 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
934 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
935 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
936 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
937 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
938 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
939 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
940 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
941 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
942 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
943 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
944 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
945 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
946 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
947 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
948 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
949 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
950 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
951 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
952 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
953 "It's well we cannot hear the screams/That we create in others' dreams."},
954 {[32]byte{(1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
955 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
956 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
957 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
958 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
959 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
960 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
961 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
962 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
963 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
964 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
965 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
966 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
967 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
968 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
969 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
970 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
971 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
972 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
973 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
974 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
975 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
976 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
977 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
978 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
979 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
980 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
981 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
982 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
983 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
984 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
985 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128)},
986 "You remind me of a TV show, but that's all right: I watch it anyway."},
987 {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
988 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
989 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
990 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
991 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
992 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
993 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
994 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
995 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
996 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
997 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
998 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
999 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
1000 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
1001 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1002 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
1003 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1004 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1005 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1006 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
1007 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1008 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1009 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
1010 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1011 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1012 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1013 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1014 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1015 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
1016 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
1017 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
1018 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128)},
1019 "C is as portable as Stonehedge!!"},
1020 {[32]byte{(1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
1021 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
1022 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
1023 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1024 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1025 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
1026 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1027 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
1028 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1029 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1030 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
1031 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1032 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
1033 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
1034 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1035 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1036 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
1037 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
1038 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
1039 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
1040 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1041 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1042 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1043 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1044 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
1045 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
1046 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
1047 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
1048 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1049 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
1050 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1051 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128)},
1052 "Even if I could be Shakespeare, I think I should still choose to be Faraday. - A. Huxley"},
1053 {[32]byte{(1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1054 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
1055 (1 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1056 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
1057 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1058 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1059 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1060 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1061 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
1062 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
1063 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1064 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
1065 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1066 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1067 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
1068 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1069 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
1070 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
1071 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
1072 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
1073 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
1074 (1 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1075 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
1076 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
1077 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
1078 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1079 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1080 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
1081 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
1082 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1083 (0 * 1) + (0 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1084 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (0 * 128)},
1085 "The fugacity of a constituent in a mixture of gases at a given temperature is proportional to its mole fraction. Lewis-Randall Rule"},
1086 {[32]byte{(1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
1087 (1 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1088 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
1089 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1090 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
1091 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
1092 (0 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1093 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1094 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1095 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1096 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
1097 (0 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
1098 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
1099 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
1100 (0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1101 (0 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (0 * 64) + (0 * 128),
1102 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
1103 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (1 * 64) + (1 * 128),
1104 (1 * 1) + (0 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1105 (0 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
1106 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (0 * 128),
1107 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
1108 (1 * 1) + (0 * 2) + (1 * 4) + (1 * 8) + (1 * 16) + (0 * 32) + (1 * 64) + (0 * 128),
1109 (0 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
1110 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (1 * 64) + (1 * 128),
1111 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1112 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1113 (1 * 1) + (1 * 2) + (0 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1114 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (1 * 16) + (1 * 32) + (0 * 64) + (0 * 128),
1115 (1 * 1) + (0 * 2) + (0 * 4) + (1 * 8) + (0 * 16) + (1 * 32) + (0 * 64) + (1 * 128),
1116 (1 * 1) + (1 * 2) + (1 * 4) + (1 * 8) + (0 * 16) + (0 * 32) + (0 * 64) + (1 * 128),
1117 (0 * 1) + (1 * 2) + (1 * 4) + (0 * 8) + (0 * 16) + (1 * 32) + (1 * 64) + (1 * 128)},
1118 "How can you write a big system without C++? -Paul Glick"},
1119 }
1120
1121 func TestGolden(t *testing.T) {
1122 for _, g := range golden {
1123 s := fmt.Sprintf("%x", Sum256([]byte(g.in)))
1124 if Sum256([]byte(g.in)) != g.out {
1125 t.Fatalf("Sum256 function: sha256(%s) = %s want %s", g.in, s, hex.EncodeToString(g.out[:]))
1126 }
1127 }
1128 }
1129
1130 func TestSize(t *testing.T) {
1131 c := New()
1132 if got := c.Size(); got != Size {
1133 t.Errorf("Size = %d; want %d", got, Size)
1134 }
1135 }
1136
1137 func TestBlockSize(t *testing.T) {
1138 c := New()
1139 if got := c.BlockSize(); got != BlockSize {
1140 t.Errorf("BlockSize = %d want %d", got, BlockSize)
1141 }
1142 }
1143
1144 var bench = New()
1145 var buf = make([]byte, 1024*1024)
1146
1147 func benchmarkSize(b *testing.B, size int) {
1148 b.SetBytes(int64(size))
1149 sum := make([]byte, bench.Size())
1150 for i := 0; i < b.N; i++ {
1151 bench.Reset()
1152 bench.Write(buf[:size])
1153 bench.Sum(sum[:0])
1154 }
1155 }
1156
1157 func BenchmarkHash8Bytes(b *testing.B) {
1158 benchmarkSize(b, 8)
1159 }
1160
1161 func BenchmarkHash1K(b *testing.B) {
1162 benchmarkSize(b, 1024)
1163 }
1164
1165 func BenchmarkHash8K(b *testing.B) {
1166 benchmarkSize(b, 8192)
1167 }
1168
1169 func BenchmarkHash1M(b *testing.B) {
1170 benchmarkSize(b, 1024*1024)
1171 }
0 //+build !noasm
1
2 /*
3 * Minio Cloud Storage, (C) 2016 Minio, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 package sha256
19
20 //go:noescape
21 func blockAvx2(h []uint32, message []uint8)
0 //+build !noasm !appengine
1
2 // SHA256 implementation for AVX2
3
4 //
5 // Minio Cloud Storage, (C) 2016 Minio, Inc.
6 //
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
10 //
11 // http://www.apache.org/licenses/LICENSE-2.0
12 //
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
18 //
19
20 //
21 // This code is based on an Intel White-Paper:
22 // "Fast SHA-256 Implementations on Intel Architecture Processors"
23 //
24 // together with the reference implementation from the following authors:
25 // James Guilford <james.guilford@intel.com>
26 // Kirk Yap <kirk.s.yap@intel.com>
27 // Tim Chen <tim.c.chen@linux.intel.com>
28 //
29 // For Golang it has been converted to Plan 9 assembly with the help of
30 // github.com/minio/asm2plan9s to assemble Intel instructions to their Plan9
31 // equivalents
32 //
33
34 #include "textflag.h"
35
36 DATA K256<>+0x000(SB)/8, $0x71374491428a2f98
37 DATA K256<>+0x008(SB)/8, $0xe9b5dba5b5c0fbcf
38 DATA K256<>+0x010(SB)/8, $0x71374491428a2f98
39 DATA K256<>+0x018(SB)/8, $0xe9b5dba5b5c0fbcf
40 DATA K256<>+0x020(SB)/8, $0x59f111f13956c25b
41 DATA K256<>+0x028(SB)/8, $0xab1c5ed5923f82a4
42 DATA K256<>+0x030(SB)/8, $0x59f111f13956c25b
43 DATA K256<>+0x038(SB)/8, $0xab1c5ed5923f82a4
44 DATA K256<>+0x040(SB)/8, $0x12835b01d807aa98
45 DATA K256<>+0x048(SB)/8, $0x550c7dc3243185be
46 DATA K256<>+0x050(SB)/8, $0x12835b01d807aa98
47 DATA K256<>+0x058(SB)/8, $0x550c7dc3243185be
48 DATA K256<>+0x060(SB)/8, $0x80deb1fe72be5d74
49 DATA K256<>+0x068(SB)/8, $0xc19bf1749bdc06a7
50 DATA K256<>+0x070(SB)/8, $0x80deb1fe72be5d74
51 DATA K256<>+0x078(SB)/8, $0xc19bf1749bdc06a7
52 DATA K256<>+0x080(SB)/8, $0xefbe4786e49b69c1
53 DATA K256<>+0x088(SB)/8, $0x240ca1cc0fc19dc6
54 DATA K256<>+0x090(SB)/8, $0xefbe4786e49b69c1
55 DATA K256<>+0x098(SB)/8, $0x240ca1cc0fc19dc6
56 DATA K256<>+0x0a0(SB)/8, $0x4a7484aa2de92c6f
57 DATA K256<>+0x0a8(SB)/8, $0x76f988da5cb0a9dc
58 DATA K256<>+0x0b0(SB)/8, $0x4a7484aa2de92c6f
59 DATA K256<>+0x0b8(SB)/8, $0x76f988da5cb0a9dc
60 DATA K256<>+0x0c0(SB)/8, $0xa831c66d983e5152
61 DATA K256<>+0x0c8(SB)/8, $0xbf597fc7b00327c8
62 DATA K256<>+0x0d0(SB)/8, $0xa831c66d983e5152
63 DATA K256<>+0x0d8(SB)/8, $0xbf597fc7b00327c8
64 DATA K256<>+0x0e0(SB)/8, $0xd5a79147c6e00bf3
65 DATA K256<>+0x0e8(SB)/8, $0x1429296706ca6351
66 DATA K256<>+0x0f0(SB)/8, $0xd5a79147c6e00bf3
67 DATA K256<>+0x0f8(SB)/8, $0x1429296706ca6351
68 DATA K256<>+0x100(SB)/8, $0x2e1b213827b70a85
69 DATA K256<>+0x108(SB)/8, $0x53380d134d2c6dfc
70 DATA K256<>+0x110(SB)/8, $0x2e1b213827b70a85
71 DATA K256<>+0x118(SB)/8, $0x53380d134d2c6dfc
72 DATA K256<>+0x120(SB)/8, $0x766a0abb650a7354
73 DATA K256<>+0x128(SB)/8, $0x92722c8581c2c92e
74 DATA K256<>+0x130(SB)/8, $0x766a0abb650a7354
75 DATA K256<>+0x138(SB)/8, $0x92722c8581c2c92e
76 DATA K256<>+0x140(SB)/8, $0xa81a664ba2bfe8a1
77 DATA K256<>+0x148(SB)/8, $0xc76c51a3c24b8b70
78 DATA K256<>+0x150(SB)/8, $0xa81a664ba2bfe8a1
79 DATA K256<>+0x158(SB)/8, $0xc76c51a3c24b8b70
80 DATA K256<>+0x160(SB)/8, $0xd6990624d192e819
81 DATA K256<>+0x168(SB)/8, $0x106aa070f40e3585
82 DATA K256<>+0x170(SB)/8, $0xd6990624d192e819
83 DATA K256<>+0x178(SB)/8, $0x106aa070f40e3585
84 DATA K256<>+0x180(SB)/8, $0x1e376c0819a4c116
85 DATA K256<>+0x188(SB)/8, $0x34b0bcb52748774c
86 DATA K256<>+0x190(SB)/8, $0x1e376c0819a4c116
87 DATA K256<>+0x198(SB)/8, $0x34b0bcb52748774c
88 DATA K256<>+0x1a0(SB)/8, $0x4ed8aa4a391c0cb3
89 DATA K256<>+0x1a8(SB)/8, $0x682e6ff35b9cca4f
90 DATA K256<>+0x1b0(SB)/8, $0x4ed8aa4a391c0cb3
91 DATA K256<>+0x1b8(SB)/8, $0x682e6ff35b9cca4f
92 DATA K256<>+0x1c0(SB)/8, $0x78a5636f748f82ee
93 DATA K256<>+0x1c8(SB)/8, $0x8cc7020884c87814
94 DATA K256<>+0x1d0(SB)/8, $0x78a5636f748f82ee
95 DATA K256<>+0x1d8(SB)/8, $0x8cc7020884c87814
96 DATA K256<>+0x1e0(SB)/8, $0xa4506ceb90befffa
97 DATA K256<>+0x1e8(SB)/8, $0xc67178f2bef9a3f7
98 DATA K256<>+0x1f0(SB)/8, $0xa4506ceb90befffa
99 DATA K256<>+0x1f8(SB)/8, $0xc67178f2bef9a3f7
100
101 DATA K256<>+0x200(SB)/8, $0x0405060700010203
102 DATA K256<>+0x208(SB)/8, $0x0c0d0e0f08090a0b
103 DATA K256<>+0x210(SB)/8, $0x0405060700010203
104 DATA K256<>+0x218(SB)/8, $0x0c0d0e0f08090a0b
105 DATA K256<>+0x220(SB)/8, $0x0b0a090803020100
106 DATA K256<>+0x228(SB)/8, $0xffffffffffffffff
107 DATA K256<>+0x230(SB)/8, $0x0b0a090803020100
108 DATA K256<>+0x238(SB)/8, $0xffffffffffffffff
109 DATA K256<>+0x240(SB)/8, $0xffffffffffffffff
110 DATA K256<>+0x248(SB)/8, $0x0b0a090803020100
111 DATA K256<>+0x250(SB)/8, $0xffffffffffffffff
112 DATA K256<>+0x258(SB)/8, $0x0b0a090803020100
113
114 GLOBL K256<>(SB), 8, $608
115
116 // func blockAvx2(h []uint32, message []uint8)
117 TEXT ·blockAvx2(SB), 7, $0
118
119 MOVQ ctx+0(FP), DI // DI: &h
120 MOVQ inp+24(FP), SI // SI: &message
121 MOVQ inplength+32(FP), DX // len(message)
122 ADDQ SI, DX // end pointer of input
123 MOVQ SP, R11 // copy stack pointer
124 SUBQ $0x220, SP // sp -= 0x220
125 ANDQ $0xfffffffffffffc00, SP // align stack frame
126 ADDQ $0x1c0, SP
127 MOVQ DI, 0x40(SP) // save ctx
128 MOVQ SI, 0x48(SP) // save input
129 MOVQ DX, 0x50(SP) // save end pointer
130 MOVQ R11, 0x58(SP) // save copy of stack pointer
131
132 WORD $0xf8c5; BYTE $0x77 // vzeroupper
133 ADDQ $0x40, SI // input++
134 MOVL (DI), AX
135 MOVQ SI, R12 // borrow $T1
136 MOVL 4(DI), BX
137 CMPQ SI, DX // $_end
138 MOVL 8(DI), CX
139 LONG $0xe4440f4c // cmove r12,rsp /* next block or random data */
140 MOVL 12(DI), DX
141 MOVL 16(DI), R8
142 MOVL 20(DI), R9
143 MOVL 24(DI), R10
144 MOVL 28(DI), R11
145
146 LEAQ K256<>(SB), BP
147 LONG $0x856f7dc5; LONG $0x00000220 // VMOVDQA YMM8, 0x220[rbp] /* vmovdqa ymm8,YMMWORD PTR [rip+0x220] */
148 LONG $0x8d6f7dc5; LONG $0x00000240 // VMOVDQA YMM9, 0x240[rbp] /* vmovdqa ymm9,YMMWORD PTR [rip+0x240] */
149 LONG $0x956f7dc5; LONG $0x00000200 // VMOVDQA YMM10, 0x200[rbp] /* vmovdqa ymm7,YMMWORD PTR [rip+0x200] */
150
151 loop0:
152 LONG $0x6f7dc1c4; BYTE $0xfa // VMOVDQA YMM7, YMM10
153
154 // Load first 16 dwords from two blocks
155 MOVOU -64(SI), X0 // vmovdqu xmm0,XMMWORD PTR [rsi-0x40]
156 MOVOU -48(SI), X1 // vmovdqu xmm1,XMMWORD PTR [rsi-0x30]
157 MOVOU -32(SI), X2 // vmovdqu xmm2,XMMWORD PTR [rsi-0x20]
158 MOVOU -16(SI), X3 // vmovdqu xmm3,XMMWORD PTR [rsi-0x10]
159
160 // Byte swap data and transpose data into high/low
161 LONG $0x387dc3c4; WORD $0x2404; BYTE $0x01 // vinserti128 ymm0,ymm0,[r12],0x1
162 LONG $0x3875c3c4; LONG $0x0110244c // vinserti128 ymm1,ymm1,0x10[r12],0x1
163 LONG $0x007de2c4; BYTE $0xc7 // vpshufb ymm0,ymm0,ymm7
164 LONG $0x386dc3c4; LONG $0x01202454 // vinserti128 ymm2,ymm2,0x20[r12],0x1
165 LONG $0x0075e2c4; BYTE $0xcf // vpshufb ymm1,ymm1,ymm7
166 LONG $0x3865c3c4; LONG $0x0130245c // vinserti128 ymm3,ymm3,0x30[r12],0x1
167
168 LEAQ K256<>(SB), BP
169 LONG $0x006de2c4; BYTE $0xd7 // vpshufb ymm2,ymm2,ymm7
170 LONG $0x65fefdc5; BYTE $0x00 // vpaddd ymm4,ymm0,[rbp]
171 LONG $0x0065e2c4; BYTE $0xdf // vpshufb ymm3,ymm3,ymm7
172 LONG $0x6dfef5c5; BYTE $0x20 // vpaddd ymm5,ymm1,0x20[rbp]
173 LONG $0x75feedc5; BYTE $0x40 // vpaddd ymm6,ymm2,0x40[rbp]
174 LONG $0x7dfee5c5; BYTE $0x60 // vpaddd ymm7,ymm3,0x60[rbp]
175
176 LONG $0x247ffdc5; BYTE $0x24 // vmovdqa [rsp],ymm4
177 XORQ R14, R14
178 LONG $0x6c7ffdc5; WORD $0x2024 // vmovdqa [rsp+0x20],ymm5
179
180 ADDQ $-0x40, SP
181 MOVQ BX, DI
182 LONG $0x347ffdc5; BYTE $0x24 // vmovdqa [rsp],ymm6
183 XORQ CX, DI // magic
184 LONG $0x7c7ffdc5; WORD $0x2024 // vmovdqa [rsp+0x20],ymm7
185 MOVQ R9, R12
186 ADDQ $0x80,BP
187
188 loop1:
189 // Schedule 48 input dwords, by doing 3 rounds of 12 each
190 // Note: SIMD instructions are interleaved with the SHA calculations
191 ADDQ $-0x40, SP
192 LONG $0x0f75e3c4; WORD $0x04e0 // vpalignr ymm4,ymm1,ymm0,0x4
193
194 // ROUND(AX, BX, CX, DX, R8, R9, R10, R11, R12, R13, R14, R15, DI, SP, 0x80)
195 LONG $0x249c0344; LONG $0x00000080 // add r11d,[rsp+0x80]
196 WORD $0x2145; BYTE $0xc4 // and r12d,r8d
197 LONG $0xf07b43c4; WORD $0x19e8 // rorx r13d,r8d,0x19
198 LONG $0x0f65e3c4; WORD $0x04fa // vpalignr ymm7,ymm3,ymm2,0x4
199 LONG $0xf07b43c4; WORD $0x0bf8 // rorx r15d,r8d,0xb
200 LONG $0x30048d42 // lea eax,[rax+r14*1]
201 LONG $0x231c8d47 // lea r11d,[r11+r12*1]
202 LONG $0xd472cdc5; BYTE $0x07 // vpsrld ymm6,ymm4,0x7
203 LONG $0xf23842c4; BYTE $0xe2 // andn r12d,r8d,r10d
204 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
205 LONG $0xf07b43c4; WORD $0x06f0 // rorx r14d,r8d,0x6
206 LONG $0xc7fefdc5 // vpaddd ymm0,ymm0,ymm7
207 LONG $0x231c8d47 // lea r11d,[r11+r12*1]
208 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
209 WORD $0x8941; BYTE $0xc7 // mov r15d,eax
210 LONG $0xd472c5c5; BYTE $0x03 // vpsrld ymm7,ymm4,0x3
211 LONG $0xf07b63c4; WORD $0x16e0 // rorx r12d,eax,0x16
212 LONG $0x2b1c8d47 // lea r11d,[r11+r13*1]
213 WORD $0x3141; BYTE $0xdf // xor r15d,ebx
214 LONG $0xf472d5c5; BYTE $0x0e // vpslld ymm5,ymm4,0xe
215 LONG $0xf07b63c4; WORD $0x0df0 // rorx r14d,eax,0xd
216 LONG $0xf07b63c4; WORD $0x02e8 // rorx r13d,eax,0x2
217 LONG $0x1a148d42 // lea edx,[rdx+r11*1]
218 LONG $0xe6efc5c5 // vpxor ymm4,ymm7,ymm6
219 WORD $0x2144; BYTE $0xff // and edi,r15d
220 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
221 WORD $0xdf31 // xor edi,ebx
222 LONG $0xfb70fdc5; BYTE $0xfa // vpshufd ymm7,ymm3,0xfa
223 WORD $0x3145; BYTE $0xee // xor r14d,r13d
224 LONG $0x3b1c8d45 // lea r11d,[r11+rdi*1]
225 WORD $0x8945; BYTE $0xc4 // mov r12d,r8d
226 LONG $0xd672cdc5; BYTE $0x0b // vpsrld ymm6,ymm6,0xb
227
228 // ROUND(R11, AX, BX, CX, DX, R8, R9, R10, R12, R13, R14, DI, R15, SP, 0x84)
229 LONG $0x24940344; LONG $0x00000084 // add r10d,[rsp+0x84]
230 WORD $0x2141; BYTE $0xd4 // and r12d,edx
231 LONG $0xf07b63c4; WORD $0x19ea // rorx r13d,edx,0x19
232 LONG $0xe5efddc5 // vpxor ymm4,ymm4,ymm5
233 LONG $0xf07be3c4; WORD $0x0bfa // rorx edi,edx,0xb
234 LONG $0x331c8d47 // lea r11d,[r11+r14*1]
235 LONG $0x22148d47 // lea r10d,[r10+r12*1]
236 LONG $0xf572d5c5; BYTE $0x0b // vpslld ymm5,ymm5,0xb
237 LONG $0xf26842c4; BYTE $0xe1 // andn r12d,edx,r9d
238 WORD $0x3141; BYTE $0xfd // xor r13d,edi
239 LONG $0xf07b63c4; WORD $0x06f2 // rorx r14d,edx,0x6
240 LONG $0xe6efddc5 // vpxor ymm4,ymm4,ymm6
241 LONG $0x22148d47 // lea r10d,[r10+r12*1]
242 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
243 WORD $0x8944; BYTE $0xdf // mov edi,r11d
244 LONG $0xd772cdc5; BYTE $0x0a // vpsrld ymm6,ymm7,0xa
245 LONG $0xf07b43c4; WORD $0x16e3 // rorx r12d,r11d,0x16
246 LONG $0x2a148d47 // lea r10d,[r10+r13*1]
247 WORD $0xc731 // xor edi,eax
248 LONG $0xe5efddc5 // vpxor ymm4,ymm4,ymm5
249 LONG $0xf07b43c4; WORD $0x0df3 // rorx r14d,r11d,0xd
250 LONG $0xf07b43c4; WORD $0x02eb // rorx r13d,r11d,0x2
251 LONG $0x110c8d42 // lea ecx,[rcx+r10*1]
252 LONG $0xd773c5c5; BYTE $0x11 // vpsrlq ymm7,ymm7,0x11
253 WORD $0x2141; BYTE $0xff // and r15d,edi
254 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
255 WORD $0x3141; BYTE $0xc7 // xor r15d,eax
256 LONG $0xc4fefdc5 // vpaddd ymm0,ymm0,ymm4
257 WORD $0x3145; BYTE $0xee // xor r14d,r13d
258 LONG $0x3a148d47 // lea r10d,[r10+r15*1]
259 WORD $0x8941; BYTE $0xd4 // mov r12d,edx
260 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
261
262 // ROUND(R10, R11, AX, BX, CX, DX, R8, R9, R12, R13, R14, R15, DI, SP, 0x88)
263 LONG $0x248c0344; LONG $0x00000088 // add r9d,[rsp+0x88]
264 WORD $0x2141; BYTE $0xcc // and r12d,ecx
265 LONG $0xf07b63c4; WORD $0x19e9 // rorx r13d,ecx,0x19
266 LONG $0xd773c5c5; BYTE $0x02 // vpsrlq ymm7,ymm7,0x2
267 LONG $0xf07b63c4; WORD $0x0bf9 // rorx r15d,ecx,0xb
268 LONG $0x32148d47 // lea r10d,[r10+r14*1]
269 LONG $0x210c8d47 // lea r9d,[r9+r12*1]
270 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
271 LONG $0xf27042c4; BYTE $0xe0 // andn r12d,ecx,r8d
272 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
273 LONG $0xf07b63c4; WORD $0x06f1 // rorx r14d,ecx,0x6
274 LONG $0x004dc2c4; BYTE $0xf0 // vpshufb ymm6,ymm6,ymm8
275 LONG $0x210c8d47 // lea r9d,[r9+r12*1]
276 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
277 WORD $0x8945; BYTE $0xd7 // mov r15d,r10d
278 LONG $0xc6fefdc5 // vpaddd ymm0,ymm0,ymm6
279 LONG $0xf07b43c4; WORD $0x16e2 // rorx r12d,r10d,0x16
280 LONG $0x290c8d47 // lea r9d,[r9+r13*1]
281 WORD $0x3145; BYTE $0xdf // xor r15d,r11d
282 LONG $0xf870fdc5; BYTE $0x50 // vpshufd ymm7,ymm0,0x50
283 LONG $0xf07b43c4; WORD $0x0df2 // rorx r14d,r10d,0xd
284 LONG $0xf07b43c4; WORD $0x02ea // rorx r13d,r10d,0x2
285 LONG $0x0b1c8d42 // lea ebx,[rbx+r9*1]
286 LONG $0xd772cdc5; BYTE $0x0a // vpsrld ymm6,ymm7,0xa
287 WORD $0x2144; BYTE $0xff // and edi,r15d
288 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
289 WORD $0x3144; BYTE $0xdf // xor edi,r11d
290 LONG $0xd773c5c5; BYTE $0x11 // vpsrlq ymm7,ymm7,0x11
291 WORD $0x3145; BYTE $0xee // xor r14d,r13d
292 LONG $0x390c8d45 // lea r9d,[r9+rdi*1]
293 WORD $0x8941; BYTE $0xcc // mov r12d,ecx
294 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
295
296 // ROUND(R9, R10, R11, AX, BX, CX, DX, R8, R12, R13, R14, DI, R15, SP, 0x8c)
297 LONG $0x24840344; LONG $0x0000008c // add r8d,[rsp+0x8c]
298 WORD $0x2141; BYTE $0xdc // and r12d,ebx
299 LONG $0xf07b63c4; WORD $0x19eb // rorx r13d,ebx,0x19
300 LONG $0xd773c5c5; BYTE $0x02 // vpsrlq ymm7,ymm7,0x2
301 LONG $0xf07be3c4; WORD $0x0bfb // rorx edi,ebx,0xb
302 LONG $0x310c8d47 // lea r9d,[r9+r14*1]
303 LONG $0x20048d47 // lea r8d,[r8+r12*1]
304 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
305 LONG $0xf26062c4; BYTE $0xe2 // andn r12d,ebx,edx
306 WORD $0x3141; BYTE $0xfd // xor r13d,edi
307 LONG $0xf07b63c4; WORD $0x06f3 // rorx r14d,ebx,0x6
308 LONG $0x004dc2c4; BYTE $0xf1 // vpshufb ymm6,ymm6,ymm9
309 LONG $0x20048d47 // lea r8d,[r8+r12*1]
310 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
311 WORD $0x8944; BYTE $0xcf // mov edi,r9d
312 LONG $0xc6fefdc5 // vpaddd ymm0,ymm0,ymm6
313 LONG $0xf07b43c4; WORD $0x16e1 // rorx r12d,r9d,0x16
314 LONG $0x28048d47 // lea r8d,[r8+r13*1]
315 WORD $0x3144; BYTE $0xd7 // xor edi,r10d
316 LONG $0x75fefdc5; BYTE $0x00 // vpaddd ymm6,ymm0,[rbp+0x0]
317 LONG $0xf07b43c4; WORD $0x0df1 // rorx r14d,r9d,0xd
318 LONG $0xf07b43c4; WORD $0x02e9 // rorx r13d,r9d,0x2
319 LONG $0x00048d42 // lea eax,[rax+r8*1]
320 WORD $0x2141; BYTE $0xff // and r15d,edi
321 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
322 WORD $0x3145; BYTE $0xd7 // xor r15d,r10d
323 WORD $0x3145; BYTE $0xee // xor r14d,r13d
324 LONG $0x38048d47 // lea r8d,[r8+r15*1]
325 WORD $0x8941; BYTE $0xdc // mov r12d,ebx
326
327 LONG $0x347ffdc5; BYTE $0x24 // vmovdqa [rsp],ymm6
328 LONG $0x0f6de3c4; WORD $0x04e1 // vpalignr ymm4,ymm2,ymm1,0x4
329
330 // ROUND(R8, R9, R10, R11, AX, BX, CX, DX, R12, R13, R14, R15, DI, SP, 0xa0)
331 LONG $0xa0249403; WORD $0x0000; BYTE $0x00 // add edx,[rsp+0xa0]
332 WORD $0x2141; BYTE $0xc4 // and r12d,eax
333 LONG $0xf07b63c4; WORD $0x19e8 // rorx r13d,eax,0x19
334 LONG $0x0f7de3c4; WORD $0x04fb // vpalignr ymm7,ymm0,ymm3,0x4
335 LONG $0xf07b63c4; WORD $0x0bf8 // rorx r15d,eax,0xb
336 LONG $0x30048d47 // lea r8d,[r8+r14*1]
337 LONG $0x22148d42 // lea edx,[rdx+r12*1]
338 LONG $0xd472cdc5; BYTE $0x07 // vpsrld ymm6,ymm4,0x7
339 LONG $0xf27862c4; BYTE $0xe1 // andn r12d,eax,ecx
340 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
341 LONG $0xf07b63c4; WORD $0x06f0 // rorx r14d,eax,0x6
342 LONG $0xcffef5c5 // vpaddd ymm1,ymm1,ymm7
343 LONG $0x22148d42 // lea edx,[rdx+r12*1]
344 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
345 WORD $0x8945; BYTE $0xc7 // mov r15d,r8d
346 LONG $0xd472c5c5; BYTE $0x03 // vpsrld ymm7,ymm4,0x3
347 LONG $0xf07b43c4; WORD $0x16e0 // rorx r12d,r8d,0x16
348 LONG $0x2a148d42 // lea edx,[rdx+r13*1]
349 WORD $0x3145; BYTE $0xcf // xor r15d,r9d
350 LONG $0xf472d5c5; BYTE $0x0e // vpslld ymm5,ymm4,0xe
351 LONG $0xf07b43c4; WORD $0x0df0 // rorx r14d,r8d,0xd
352 LONG $0xf07b43c4; WORD $0x02e8 // rorx r13d,r8d,0x2
353 LONG $0x131c8d45 // lea r11d,[r11+rdx*1]
354 LONG $0xe6efc5c5 // vpxor ymm4,ymm7,ymm6
355 WORD $0x2144; BYTE $0xff // and edi,r15d
356 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
357 WORD $0x3144; BYTE $0xcf // xor edi,r9d
358 LONG $0xf870fdc5; BYTE $0xfa // vpshufd ymm7,ymm0,0xfa
359 WORD $0x3145; BYTE $0xee // xor r14d,r13d
360 WORD $0x148d; BYTE $0x3a // lea edx,[rdx+rdi*1]
361 WORD $0x8941; BYTE $0xc4 // mov r12d,eax
362 LONG $0xd672cdc5; BYTE $0x0b // vpsrld ymm6,ymm6,0xb
363
364 // ROUND(DX, R8, R9, R10, R11, AX, BX, CX, R12, R13, R14, DI, R15, SP, 0xa4)
365 LONG $0xa4248c03; WORD $0x0000; BYTE $0x00 // add ecx,[rsp+0xa4]
366 WORD $0x2145; BYTE $0xdc // and r12d,r11d
367 LONG $0xf07b43c4; WORD $0x19eb // rorx r13d,r11d,0x19
368 LONG $0xe5efddc5 // vpxor ymm4,ymm4,ymm5
369 LONG $0xf07bc3c4; WORD $0x0bfb // rorx edi,r11d,0xb
370 LONG $0x32148d42 // lea edx,[rdx+r14*1]
371 LONG $0x210c8d42 // lea ecx,[rcx+r12*1]
372 LONG $0xf572d5c5; BYTE $0x0b // vpslld ymm5,ymm5,0xb
373 LONG $0xf22062c4; BYTE $0xe3 // andn r12d,r11d,ebx
374 WORD $0x3141; BYTE $0xfd // xor r13d,edi
375 LONG $0xf07b43c4; WORD $0x06f3 // rorx r14d,r11d,0x6
376 LONG $0xe6efddc5 // vpxor ymm4,ymm4,ymm6
377 LONG $0x210c8d42 // lea ecx,[rcx+r12*1]
378 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
379 WORD $0xd789 // mov edi,edx
380 LONG $0xd772cdc5; BYTE $0x0a // vpsrld ymm6,ymm7,0xa
381 LONG $0xf07b63c4; WORD $0x16e2 // rorx r12d,edx,0x16
382 LONG $0x290c8d42 // lea ecx,[rcx+r13*1]
383 WORD $0x3144; BYTE $0xc7 // xor edi,r8d
384 LONG $0xe5efddc5 // vpxor ymm4,ymm4,ymm5
385 LONG $0xf07b63c4; WORD $0x0df2 // rorx r14d,edx,0xd
386 LONG $0xf07b63c4; WORD $0x02ea // rorx r13d,edx,0x2
387 LONG $0x0a148d45 // lea r10d,[r10+rcx*1]
388 LONG $0xd773c5c5; BYTE $0x11 // vpsrlq ymm7,ymm7,0x11
389 WORD $0x2141; BYTE $0xff // and r15d,edi
390 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
391 WORD $0x3145; BYTE $0xc7 // xor r15d,r8d
392 LONG $0xccfef5c5 // vpaddd ymm1,ymm1,ymm4
393 WORD $0x3145; BYTE $0xee // xor r14d,r13d
394 LONG $0x390c8d42 // lea ecx,[rcx+r15*1]
395 WORD $0x8945; BYTE $0xdc // mov r12d,r11d
396 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
397
398 // ROUND(CX, DX, R8, R9, R10, R11, AX, BX, R12, R13, R14, R15, DI, SP, 0xa8)
399 LONG $0xa8249c03; WORD $0x0000; BYTE $0x00 // add ebx,[rsp+0xa8]
400 WORD $0x2145; BYTE $0xd4 // and r12d,r10d
401 LONG $0xf07b43c4; WORD $0x19ea // rorx r13d,r10d,0x19
402 LONG $0xd773c5c5; BYTE $0x02 // vpsrlq ymm7,ymm7,0x2
403 LONG $0xf07b43c4; WORD $0x0bfa // rorx r15d,r10d,0xb
404 LONG $0x310c8d42 // lea ecx,[rcx+r14*1]
405 LONG $0x231c8d42 // lea ebx,[rbx+r12*1]
406 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
407 LONG $0xf22862c4; BYTE $0xe0 // andn r12d,r10d,eax
408 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
409 LONG $0xf07b43c4; WORD $0x06f2 // rorx r14d,r10d,0x6
410 LONG $0x004dc2c4; BYTE $0xf0 // vpshufb ymm6,ymm6,ymm8
411 LONG $0x231c8d42 // lea ebx,[rbx+r12*1]
412 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
413 WORD $0x8941; BYTE $0xcf // mov r15d,ecx
414 LONG $0xcefef5c5 // vpaddd ymm1,ymm1,ymm6
415 LONG $0xf07b63c4; WORD $0x16e1 // rorx r12d,ecx,0x16
416 LONG $0x2b1c8d42 // lea ebx,[rbx+r13*1]
417 WORD $0x3141; BYTE $0xd7 // xor r15d,edx
418 LONG $0xf970fdc5; BYTE $0x50 // vpshufd ymm7,ymm1,0x50
419 LONG $0xf07b63c4; WORD $0x0df1 // rorx r14d,ecx,0xd
420 LONG $0xf07b63c4; WORD $0x02e9 // rorx r13d,ecx,0x2
421 LONG $0x190c8d45 // lea r9d,[r9+rbx*1]
422 LONG $0xd772cdc5; BYTE $0x0a // vpsrld ymm6,ymm7,0xa
423 WORD $0x2144; BYTE $0xff // and edi,r15d
424 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
425 WORD $0xd731 // xor edi,edx
426 LONG $0xd773c5c5; BYTE $0x11 // vpsrlq ymm7,ymm7,0x11
427 WORD $0x3145; BYTE $0xee // xor r14d,r13d
428 WORD $0x1c8d; BYTE $0x3b // lea ebx,[rbx+rdi*1]
429 WORD $0x8945; BYTE $0xd4 // mov r12d,r10d
430 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
431
432 // ROUND(BX, CX, DX, R8, R9, R10, R11, AX, R12, R13, R14, DI, R15, SP, 0xac)
433 LONG $0xac248403; WORD $0x0000; BYTE $0x00 // add eax,[rsp+0xac]
434 WORD $0x2145; BYTE $0xcc // and r12d,r9d
435 LONG $0xf07b43c4; WORD $0x19e9 // rorx r13d,r9d,0x19
436 LONG $0xd773c5c5; BYTE $0x02 // vpsrlq ymm7,ymm7,0x2
437 LONG $0xf07bc3c4; WORD $0x0bf9 // rorx edi,r9d,0xb
438 LONG $0x331c8d42 // lea ebx,[rbx+r14*1]
439 LONG $0x20048d42 // lea eax,[rax+r12*1]
440 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
441 LONG $0xf23042c4; BYTE $0xe3 // andn r12d,r9d,r11d
442 WORD $0x3141; BYTE $0xfd // xor r13d,edi
443 LONG $0xf07b43c4; WORD $0x06f1 // rorx r14d,r9d,0x6
444 LONG $0x004dc2c4; BYTE $0xf1 // vpshufb ymm6,ymm6,ymm9
445 LONG $0x20048d42 // lea eax,[rax+r12*1]
446 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
447 WORD $0xdf89 // mov edi,ebx
448 LONG $0xcefef5c5 // vpaddd ymm1,ymm1,ymm6
449 LONG $0xf07b63c4; WORD $0x16e3 // rorx r12d,ebx,0x16
450 LONG $0x28048d42 // lea eax,[rax+r13*1]
451 WORD $0xcf31 // xor edi,ecx
452 LONG $0x75fef5c5; BYTE $0x20 // vpaddd ymm6,ymm1,[rbp+0x20]
453 LONG $0xf07b63c4; WORD $0x0df3 // rorx r14d,ebx,0xd
454 LONG $0xf07b63c4; WORD $0x02eb // rorx r13d,ebx,0x2
455 LONG $0x00048d45 // lea r8d,[r8+rax*1]
456 WORD $0x2141; BYTE $0xff // and r15d,edi
457 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
458 WORD $0x3141; BYTE $0xcf // xor r15d,ecx
459 WORD $0x3145; BYTE $0xee // xor r14d,r13d
460 LONG $0x38048d42 // lea eax,[rax+r15*1]
461 WORD $0x8945; BYTE $0xcc // mov r12d,r9d
462
463 LONG $0x747ffdc5; WORD $0x2024 // vmovdqa [rsp+0x20],ymm6
464
465 LONG $0x24648d48; BYTE $0xc0 // lea rsp,[rsp-0x40]
466 LONG $0x0f65e3c4; WORD $0x04e2 // vpalignr ymm4,ymm3,ymm2,0x4
467
468 // ROUND(AX, BX, CX, DX, R8, R9, R10, R11, R12, R13, R14, R15, DI, SP, 0x80)
469 LONG $0x249c0344; LONG $0x00000080 // add r11d,[rsp+0x80]
470 WORD $0x2145; BYTE $0xc4 // and r12d,r8d
471 LONG $0xf07b43c4; WORD $0x19e8 // rorx r13d,r8d,0x19
472 LONG $0x0f75e3c4; WORD $0x04f8 // vpalignr ymm7,ymm1,ymm0,0x4
473 LONG $0xf07b43c4; WORD $0x0bf8 // rorx r15d,r8d,0xb
474 LONG $0x30048d42 // lea eax,[rax+r14*1]
475 LONG $0x231c8d47 // lea r11d,[r11+r12*1]
476 LONG $0xd472cdc5; BYTE $0x07 // vpsrld ymm6,ymm4,0x7
477 LONG $0xf23842c4; BYTE $0xe2 // andn r12d,r8d,r10d
478 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
479 LONG $0xf07b43c4; WORD $0x06f0 // rorx r14d,r8d,0x6
480 LONG $0xd7feedc5 // vpaddd ymm2,ymm2,ymm7
481 LONG $0x231c8d47 // lea r11d,[r11+r12*1]
482 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
483 WORD $0x8941; BYTE $0xc7 // mov r15d,eax
484 LONG $0xd472c5c5; BYTE $0x03 // vpsrld ymm7,ymm4,0x3
485 LONG $0xf07b63c4; WORD $0x16e0 // rorx r12d,eax,0x16
486 LONG $0x2b1c8d47 // lea r11d,[r11+r13*1]
487 WORD $0x3141; BYTE $0xdf // xor r15d,ebx
488 LONG $0xf472d5c5; BYTE $0x0e // vpslld ymm5,ymm4,0xe
489 LONG $0xf07b63c4; WORD $0x0df0 // rorx r14d,eax,0xd
490 LONG $0xf07b63c4; WORD $0x02e8 // rorx r13d,eax,0x2
491 LONG $0x1a148d42 // lea edx,[rdx+r11*1]
492 LONG $0xe6efc5c5 // vpxor ymm4,ymm7,ymm6
493 WORD $0x2144; BYTE $0xff // and edi,r15d
494 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
495 WORD $0xdf31 // xor edi,ebx
496 LONG $0xf970fdc5; BYTE $0xfa // vpshufd ymm7,ymm1,0xfa
497 WORD $0x3145; BYTE $0xee // xor r14d,r13d
498 LONG $0x3b1c8d45 // lea r11d,[r11+rdi*1]
499 WORD $0x8945; BYTE $0xc4 // mov r12d,r8d
500 LONG $0xd672cdc5; BYTE $0x0b // vpsrld ymm6,ymm6,0xb
501
502 // ROUND(R11, AX, BX, CX, DX, R8, R9, R10, R12, R13, R14, DI, R15, SP, 0x84)
503 LONG $0x24940344; LONG $0x00000084 // add r10d,[rsp+0x84]
504 WORD $0x2141; BYTE $0xd4 // and r12d,edx
505 LONG $0xf07b63c4; WORD $0x19ea // rorx r13d,edx,0x19
506 LONG $0xe5efddc5 // vpxor ymm4,ymm4,ymm5
507 LONG $0xf07be3c4; WORD $0x0bfa // rorx edi,edx,0xb
508 LONG $0x331c8d47 // lea r11d,[r11+r14*1]
509 LONG $0x22148d47 // lea r10d,[r10+r12*1]
510 LONG $0xf572d5c5; BYTE $0x0b // vpslld ymm5,ymm5,0xb
511 LONG $0xf26842c4; BYTE $0xe1 // andn r12d,edx,r9d
512 WORD $0x3141; BYTE $0xfd // xor r13d,edi
513 LONG $0xf07b63c4; WORD $0x06f2 // rorx r14d,edx,0x6
514 LONG $0xe6efddc5 // vpxor ymm4,ymm4,ymm6
515 LONG $0x22148d47 // lea r10d,[r10+r12*1]
516 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
517 WORD $0x8944; BYTE $0xdf // mov edi,r11d
518 LONG $0xd772cdc5; BYTE $0x0a // vpsrld ymm6,ymm7,0xa
519 LONG $0xf07b43c4; WORD $0x16e3 // rorx r12d,r11d,0x16
520 LONG $0x2a148d47 // lea r10d,[r10+r13*1]
521 WORD $0xc731 // xor edi,eax
522 LONG $0xe5efddc5 // vpxor ymm4,ymm4,ymm5
523 LONG $0xf07b43c4; WORD $0x0df3 // rorx r14d,r11d,0xd
524 LONG $0xf07b43c4; WORD $0x02eb // rorx r13d,r11d,0x2
525 LONG $0x110c8d42 // lea ecx,[rcx+r10*1]
526 LONG $0xd773c5c5; BYTE $0x11 // vpsrlq ymm7,ymm7,0x11
527 WORD $0x2141; BYTE $0xff // and r15d,edi
528 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
529 WORD $0x3141; BYTE $0xc7 // xor r15d,eax
530 LONG $0xd4feedc5 // vpaddd ymm2,ymm2,ymm4
531 WORD $0x3145; BYTE $0xee // xor r14d,r13d
532 LONG $0x3a148d47 // lea r10d,[r10+r15*1]
533 WORD $0x8941; BYTE $0xd4 // mov r12d,edx
534 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
535
536 // ROUND(R10, R11, AX, BX, CX, DX, R8, R9, R12, R13, R14, R15, DI, SP, 0x88)
537 LONG $0x248c0344; LONG $0x00000088 // add r9d,[rsp+0x88]
538 WORD $0x2141; BYTE $0xcc // and r12d,ecx
539 LONG $0xf07b63c4; WORD $0x19e9 // rorx r13d,ecx,0x19
540 LONG $0xd773c5c5; BYTE $0x02 // vpsrlq ymm7,ymm7,0x2
541 LONG $0xf07b63c4; WORD $0x0bf9 // rorx r15d,ecx,0xb
542 LONG $0x32148d47 // lea r10d,[r10+r14*1]
543 LONG $0x210c8d47 // lea r9d,[r9+r12*1]
544 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
545 LONG $0xf27042c4; BYTE $0xe0 // andn r12d,ecx,r8d
546 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
547 LONG $0xf07b63c4; WORD $0x06f1 // rorx r14d,ecx,0x6
548 LONG $0x004dc2c4; BYTE $0xf0 // vpshufb ymm6,ymm6,ymm8
549 LONG $0x210c8d47 // lea r9d,[r9+r12*1]
550 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
551 WORD $0x8945; BYTE $0xd7 // mov r15d,r10d
552 LONG $0xd6feedc5 // vpaddd ymm2,ymm2,ymm6
553 LONG $0xf07b43c4; WORD $0x16e2 // rorx r12d,r10d,0x16
554 LONG $0x290c8d47 // lea r9d,[r9+r13*1]
555 WORD $0x3145; BYTE $0xdf // xor r15d,r11d
556 LONG $0xfa70fdc5; BYTE $0x50 // vpshufd ymm7,ymm2,0x50
557 LONG $0xf07b43c4; WORD $0x0df2 // rorx r14d,r10d,0xd
558 LONG $0xf07b43c4; WORD $0x02ea // rorx r13d,r10d,0x2
559 LONG $0x0b1c8d42 // lea ebx,[rbx+r9*1]
560 LONG $0xd772cdc5; BYTE $0x0a // vpsrld ymm6,ymm7,0xa
561 WORD $0x2144; BYTE $0xff // and edi,r15d
562 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
563 WORD $0x3144; BYTE $0xdf // xor edi,r11d
564 LONG $0xd773c5c5; BYTE $0x11 // vpsrlq ymm7,ymm7,0x11
565 WORD $0x3145; BYTE $0xee // xor r14d,r13d
566 LONG $0x390c8d45 // lea r9d,[r9+rdi*1]
567 WORD $0x8941; BYTE $0xcc // mov r12d,ecx
568 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
569
570 // ROUND(R9, R10, R11, AX, BX, CX, DX, R8, R12, R13, R14, DI, R15, SP, 0x8c)
571 LONG $0x24840344; LONG $0x0000008c // add r8d,[rsp+0x8c]
572 WORD $0x2141; BYTE $0xdc // and r12d,ebx
573 LONG $0xf07b63c4; WORD $0x19eb // rorx r13d,ebx,0x19
574 LONG $0xd773c5c5; BYTE $0x02 // vpsrlq ymm7,ymm7,0x2
575 LONG $0xf07be3c4; WORD $0x0bfb // rorx edi,ebx,0xb
576 LONG $0x310c8d47 // lea r9d,[r9+r14*1]
577 LONG $0x20048d47 // lea r8d,[r8+r12*1]
578 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
579 LONG $0xf26062c4; BYTE $0xe2 // andn r12d,ebx,edx
580 WORD $0x3141; BYTE $0xfd // xor r13d,edi
581 LONG $0xf07b63c4; WORD $0x06f3 // rorx r14d,ebx,0x6
582 LONG $0x004dc2c4; BYTE $0xf1 // vpshufb ymm6,ymm6,ymm9
583 LONG $0x20048d47 // lea r8d,[r8+r12*1]
584 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
585 WORD $0x8944; BYTE $0xcf // mov edi,r9d
586 LONG $0xd6feedc5 // vpaddd ymm2,ymm2,ymm6
587 LONG $0xf07b43c4; WORD $0x16e1 // rorx r12d,r9d,0x16
588 LONG $0x28048d47 // lea r8d,[r8+r13*1]
589 WORD $0x3144; BYTE $0xd7 // xor edi,r10d
590 LONG $0x75feedc5; BYTE $0x40 // vpaddd ymm6,ymm2,[rbp+0x40]
591 LONG $0xf07b43c4; WORD $0x0df1 // rorx r14d,r9d,0xd
592 LONG $0xf07b43c4; WORD $0x02e9 // rorx r13d,r9d,0x2
593 LONG $0x00048d42 // lea eax,[rax+r8*1]
594 WORD $0x2141; BYTE $0xff // and r15d,edi
595 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
596 WORD $0x3145; BYTE $0xd7 // xor r15d,r10d
597 WORD $0x3145; BYTE $0xee // xor r14d,r13d
598 LONG $0x38048d47 // lea r8d,[r8+r15*1]
599 WORD $0x8941; BYTE $0xdc // mov r12d,ebx
600
601 LONG $0x347ffdc5; BYTE $0x24 // vmovdqa [rsp],ymm6
602 LONG $0x0f7de3c4; WORD $0x04e3 // vpalignr ymm4,ymm0,ymm3,0x4
603
604 // ROUND(R8, R9, R10, R11, AX, BX, CX, DX, R12, R13, R14, R15, DI, SP, 0xa0)
605 LONG $0xa0249403; WORD $0x0000; BYTE $0x00 // add edx,[rsp+0xa0]
606 WORD $0x2141; BYTE $0xc4 // and r12d,eax
607 LONG $0xf07b63c4; WORD $0x19e8 // rorx r13d,eax,0x19
608 LONG $0x0f6de3c4; WORD $0x04f9 // vpalignr ymm7,ymm2,ymm1,0x4
609 LONG $0xf07b63c4; WORD $0x0bf8 // rorx r15d,eax,0xb
610 LONG $0x30048d47 // lea r8d,[r8+r14*1]
611 LONG $0x22148d42 // lea edx,[rdx+r12*1]
612 LONG $0xd472cdc5; BYTE $0x07 // vpsrld ymm6,ymm4,0x7
613 LONG $0xf27862c4; BYTE $0xe1 // andn r12d,eax,ecx
614 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
615 LONG $0xf07b63c4; WORD $0x06f0 // rorx r14d,eax,0x6
616 LONG $0xdffee5c5 // vpaddd ymm3,ymm3,ymm7
617 LONG $0x22148d42 // lea edx,[rdx+r12*1]
618 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
619 WORD $0x8945; BYTE $0xc7 // mov r15d,r8d
620 LONG $0xd472c5c5; BYTE $0x03 // vpsrld ymm7,ymm4,0x3
621 LONG $0xf07b43c4; WORD $0x16e0 // rorx r12d,r8d,0x16
622 LONG $0x2a148d42 // lea edx,[rdx+r13*1]
623 WORD $0x3145; BYTE $0xcf // xor r15d,r9d
624 LONG $0xf472d5c5; BYTE $0x0e // vpslld ymm5,ymm4,0xe
625 LONG $0xf07b43c4; WORD $0x0df0 // rorx r14d,r8d,0xd
626 LONG $0xf07b43c4; WORD $0x02e8 // rorx r13d,r8d,0x2
627 LONG $0x131c8d45 // lea r11d,[r11+rdx*1]
628 LONG $0xe6efc5c5 // vpxor ymm4,ymm7,ymm6
629 WORD $0x2144; BYTE $0xff // and edi,r15d
630 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
631 WORD $0x3144; BYTE $0xcf // xor edi,r9d
632 LONG $0xfa70fdc5; BYTE $0xfa // vpshufd ymm7,ymm2,0xfa
633 WORD $0x3145; BYTE $0xee // xor r14d,r13d
634 WORD $0x148d; BYTE $0x3a // lea edx,[rdx+rdi*1]
635 WORD $0x8941; BYTE $0xc4 // mov r12d,eax
636 LONG $0xd672cdc5; BYTE $0x0b // vpsrld ymm6,ymm6,0xb
637
638 // ROUND(DX, R8, R9, R10, R11, AX, BX, CX, R12, R13, R14, DI, R15, SP, 0xa4)
639 LONG $0xa4248c03; WORD $0x0000; BYTE $0x00 // add ecx,[rsp+0xa4]
640 WORD $0x2145; BYTE $0xdc // and r12d,r11d
641 LONG $0xf07b43c4; WORD $0x19eb // rorx r13d,r11d,0x19
642 LONG $0xe5efddc5 // vpxor ymm4,ymm4,ymm5
643 LONG $0xf07bc3c4; WORD $0x0bfb // rorx edi,r11d,0xb
644 LONG $0x32148d42 // lea edx,[rdx+r14*1]
645 LONG $0x210c8d42 // lea ecx,[rcx+r12*1]
646 LONG $0xf572d5c5; BYTE $0x0b // vpslld ymm5,ymm5,0xb
647 LONG $0xf22062c4; BYTE $0xe3 // andn r12d,r11d,ebx
648 WORD $0x3141; BYTE $0xfd // xor r13d,edi
649 LONG $0xf07b43c4; WORD $0x06f3 // rorx r14d,r11d,0x6
650 LONG $0xe6efddc5 // vpxor ymm4,ymm4,ymm6
651 LONG $0x210c8d42 // lea ecx,[rcx+r12*1]
652 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
653 WORD $0xd789 // mov edi,edx
654 LONG $0xd772cdc5; BYTE $0x0a // vpsrld ymm6,ymm7,0xa
655 LONG $0xf07b63c4; WORD $0x16e2 // rorx r12d,edx,0x16
656 LONG $0x290c8d42 // lea ecx,[rcx+r13*1]
657 WORD $0x3144; BYTE $0xc7 // xor edi,r8d
658 LONG $0xe5efddc5 // vpxor ymm4,ymm4,ymm5
659 LONG $0xf07b63c4; WORD $0x0df2 // rorx r14d,edx,0xd
660 LONG $0xf07b63c4; WORD $0x02ea // rorx r13d,edx,0x2
661 LONG $0x0a148d45 // lea r10d,[r10+rcx*1]
662 LONG $0xd773c5c5; BYTE $0x11 // vpsrlq ymm7,ymm7,0x11
663 WORD $0x2141; BYTE $0xff // and r15d,edi
664 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
665 WORD $0x3145; BYTE $0xc7 // xor r15d,r8d
666 LONG $0xdcfee5c5 // vpaddd ymm3,ymm3,ymm4
667 WORD $0x3145; BYTE $0xee // xor r14d,r13d
668 LONG $0x390c8d42 // lea ecx,[rcx+r15*1]
669 WORD $0x8945; BYTE $0xdc // mov r12d,r11d
670 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
671
672 // ROUND(CX, DX, R8, R9, R10, R11, AX, BX, R12, R13, R14, R15, DI, SP, 0xa8)
673 LONG $0xa8249c03; WORD $0x0000; BYTE $0x00 // add ebx,[rsp+0xa8]
674 WORD $0x2145; BYTE $0xd4 // and r12d,r10d
675 LONG $0xf07b43c4; WORD $0x19ea // rorx r13d,r10d,0x19
676 LONG $0xd773c5c5; BYTE $0x02 // vpsrlq ymm7,ymm7,0x2
677 LONG $0xf07b43c4; WORD $0x0bfa // rorx r15d,r10d,0xb
678 LONG $0x310c8d42 // lea ecx,[rcx+r14*1]
679 LONG $0x231c8d42 // lea ebx,[rbx+r12*1]
680 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
681 LONG $0xf22862c4; BYTE $0xe0 // andn r12d,r10d,eax
682 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
683 LONG $0xf07b43c4; WORD $0x06f2 // rorx r14d,r10d,0x6
684 LONG $0x004dc2c4; BYTE $0xf0 // vpshufb ymm6,ymm6,ymm8
685 LONG $0x231c8d42 // lea ebx,[rbx+r12*1]
686 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
687 WORD $0x8941; BYTE $0xcf // mov r15d,ecx
688 LONG $0xdefee5c5 // vpaddd ymm3,ymm3,ymm6
689 LONG $0xf07b63c4; WORD $0x16e1 // rorx r12d,ecx,0x16
690 LONG $0x2b1c8d42 // lea ebx,[rbx+r13*1]
691 WORD $0x3141; BYTE $0xd7 // xor r15d,edx
692 LONG $0xfb70fdc5; BYTE $0x50 // vpshufd ymm7,ymm3,0x50
693 LONG $0xf07b63c4; WORD $0x0df1 // rorx r14d,ecx,0xd
694 LONG $0xf07b63c4; WORD $0x02e9 // rorx r13d,ecx,0x2
695 LONG $0x190c8d45 // lea r9d,[r9+rbx*1]
696 LONG $0xd772cdc5; BYTE $0x0a // vpsrld ymm6,ymm7,0xa
697 WORD $0x2144; BYTE $0xff // and edi,r15d
698 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
699 WORD $0xd731 // xor edi,edx
700 LONG $0xd773c5c5; BYTE $0x11 // vpsrlq ymm7,ymm7,0x11
701 WORD $0x3145; BYTE $0xee // xor r14d,r13d
702 WORD $0x1c8d; BYTE $0x3b // lea ebx,[rbx+rdi*1]
703 WORD $0x8945; BYTE $0xd4 // mov r12d,r10d
704 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
705
706 // ROUND(BX, CX, DX, R8, R9, R10, R11, AX, R12, R13, R14, DI, R15, SP, 0xac)
707 LONG $0xac248403; WORD $0x0000; BYTE $0x00 // add eax,[rsp+0xac]
708 WORD $0x2145; BYTE $0xcc // and r12d,r9d
709 LONG $0xf07b43c4; WORD $0x19e9 // rorx r13d,r9d,0x19
710 LONG $0xd773c5c5; BYTE $0x02 // vpsrlq ymm7,ymm7,0x2
711 LONG $0xf07bc3c4; WORD $0x0bf9 // rorx edi,r9d,0xb
712 LONG $0x331c8d42 // lea ebx,[rbx+r14*1]
713 LONG $0x20048d42 // lea eax,[rax+r12*1]
714 LONG $0xf7efcdc5 // vpxor ymm6,ymm6,ymm7
715 LONG $0xf23042c4; BYTE $0xe3 // andn r12d,r9d,r11d
716 WORD $0x3141; BYTE $0xfd // xor r13d,edi
717 LONG $0xf07b43c4; WORD $0x06f1 // rorx r14d,r9d,0x6
718 LONG $0x004dc2c4; BYTE $0xf1 // vpshufb ymm6,ymm6,ymm9
719 LONG $0x20048d42 // lea eax,[rax+r12*1]
720 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
721 WORD $0xdf89 // mov edi,ebx
722 LONG $0xdefee5c5 // vpaddd ymm3,ymm3,ymm6
723 LONG $0xf07b63c4; WORD $0x16e3 // rorx r12d,ebx,0x16
724 LONG $0x28048d42 // lea eax,[rax+r13*1]
725 WORD $0xcf31 // xor edi,ecx
726 LONG $0x75fee5c5; BYTE $0x60 // vpaddd ymm6,ymm3,[rbp+0x60]
727 LONG $0xf07b63c4; WORD $0x0df3 // rorx r14d,ebx,0xd
728 LONG $0xf07b63c4; WORD $0x02eb // rorx r13d,ebx,0x2
729 LONG $0x00048d45 // lea r8d,[r8+rax*1]
730 WORD $0x2141; BYTE $0xff // and r15d,edi
731 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
732 WORD $0x3141; BYTE $0xcf // xor r15d,ecx
733 WORD $0x3145; BYTE $0xee // xor r14d,r13d
734 LONG $0x38048d42 // lea eax,[rax+r15*1]
735 WORD $0x8945; BYTE $0xcc // mov r12d,r9d
736
737 LONG $0x747ffdc5; WORD $0x2024 // vmovdqa [rsp+0x20],ymm6
738 ADDQ $0x80, BP
739
740 CMPB 0x3(BP),$0x0
741 JNE loop1
742
743 // ROUND(AX, BX, CX, DX, R8, R9, R10, R11, R12, R13, R14, R15, DI, SP, 0x40)
744 LONG $0x245c0344; BYTE $0x40 // add r11d,[rsp+0x40]
745 WORD $0x2145; BYTE $0xc4 // and r12d,r8d
746 LONG $0xf07b43c4; WORD $0x19e8 // rorx r13d,r8d,0x19
747 LONG $0xf07b43c4; WORD $0x0bf8 // rorx r15d,r8d,0xb
748 LONG $0x30048d42 // lea eax,[rax+r14*1]
749 LONG $0x231c8d47 // lea r11d,[r11+r12*1]
750 LONG $0xf23842c4; BYTE $0xe2 // andn r12d,r8d,r10d
751 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
752 LONG $0xf07b43c4; WORD $0x06f0 // rorx r14d,r8d,0x6
753 LONG $0x231c8d47 // lea r11d,[r11+r12*1]
754 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
755 WORD $0x8941; BYTE $0xc7 // mov r15d,eax
756 LONG $0xf07b63c4; WORD $0x16e0 // rorx r12d,eax,0x16
757 LONG $0x2b1c8d47 // lea r11d,[r11+r13*1]
758 WORD $0x3141; BYTE $0xdf // xor r15d,ebx
759 LONG $0xf07b63c4; WORD $0x0df0 // rorx r14d,eax,0xd
760 LONG $0xf07b63c4; WORD $0x02e8 // rorx r13d,eax,0x2
761 LONG $0x1a148d42 // lea edx,[rdx+r11*1]
762 WORD $0x2144; BYTE $0xff // and edi,r15d
763 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
764 WORD $0xdf31 // xor edi,ebx
765 WORD $0x3145; BYTE $0xee // xor r14d,r13d
766 LONG $0x3b1c8d45 // lea r11d,[r11+rdi*1]
767 WORD $0x8945; BYTE $0xc4 // mov r12d,r8d
768
769 // ROUND(R11, AX, BX, CX, DX, R8, R9, R10, R12, R13, R14, DI, R15, SP, 0x44)
770 LONG $0x24540344; BYTE $0x44 // add r10d,[rsp+0x44]
771 WORD $0x2141; BYTE $0xd4 // and r12d,edx
772 LONG $0xf07b63c4; WORD $0x19ea // rorx r13d,edx,0x19
773 LONG $0xf07be3c4; WORD $0x0bfa // rorx edi,edx,0xb
774 LONG $0x331c8d47 // lea r11d,[r11+r14*1]
775 LONG $0x22148d47 // lea r10d,[r10+r12*1]
776 LONG $0xf26842c4; BYTE $0xe1 // andn r12d,edx,r9d
777 WORD $0x3141; BYTE $0xfd // xor r13d,edi
778 LONG $0xf07b63c4; WORD $0x06f2 // rorx r14d,edx,0x6
779 LONG $0x22148d47 // lea r10d,[r10+r12*1]
780 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
781 WORD $0x8944; BYTE $0xdf // mov edi,r11d
782 LONG $0xf07b43c4; WORD $0x16e3 // rorx r12d,r11d,0x16
783 LONG $0x2a148d47 // lea r10d,[r10+r13*1]
784 WORD $0xc731 // xor edi,eax
785 LONG $0xf07b43c4; WORD $0x0df3 // rorx r14d,r11d,0xd
786 LONG $0xf07b43c4; WORD $0x02eb // rorx r13d,r11d,0x2
787 LONG $0x110c8d42 // lea ecx,[rcx+r10*1]
788 WORD $0x2141; BYTE $0xff // and r15d,edi
789 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
790 WORD $0x3141; BYTE $0xc7 // xor r15d,eax
791 WORD $0x3145; BYTE $0xee // xor r14d,r13d
792 LONG $0x3a148d47 // lea r10d,[r10+r15*1]
793 WORD $0x8941; BYTE $0xd4 // mov r12d,edx
794
795 // ROUND(R10, R11, AX, BX, CX, DX, R8, R9, R12, R13, R14, R15, DI, SP, 0x48)
796 LONG $0x244c0344; BYTE $0x48 // add r9d,[rsp+0x48]
797 WORD $0x2141; BYTE $0xcc // and r12d,ecx
798 LONG $0xf07b63c4; WORD $0x19e9 // rorx r13d,ecx,0x19
799 LONG $0xf07b63c4; WORD $0x0bf9 // rorx r15d,ecx,0xb
800 LONG $0x32148d47 // lea r10d,[r10+r14*1]
801 LONG $0x210c8d47 // lea r9d,[r9+r12*1]
802 LONG $0xf27042c4; BYTE $0xe0 // andn r12d,ecx,r8d
803 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
804 LONG $0xf07b63c4; WORD $0x06f1 // rorx r14d,ecx,0x6
805 LONG $0x210c8d47 // lea r9d,[r9+r12*1]
806 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
807 WORD $0x8945; BYTE $0xd7 // mov r15d,r10d
808 LONG $0xf07b43c4; WORD $0x16e2 // rorx r12d,r10d,0x16
809 LONG $0x290c8d47 // lea r9d,[r9+r13*1]
810 WORD $0x3145; BYTE $0xdf // xor r15d,r11d
811 LONG $0xf07b43c4; WORD $0x0df2 // rorx r14d,r10d,0xd
812 LONG $0xf07b43c4; WORD $0x02ea // rorx r13d,r10d,0x2
813 LONG $0x0b1c8d42 // lea ebx,[rbx+r9*1]
814 WORD $0x2144; BYTE $0xff // and edi,r15d
815 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
816 WORD $0x3144; BYTE $0xdf // xor edi,r11d
817 WORD $0x3145; BYTE $0xee // xor r14d,r13d
818 LONG $0x390c8d45 // lea r9d,[r9+rdi*1]
819 WORD $0x8941; BYTE $0xcc // mov r12d,ecx
820
821 // ROUND(R9, R10, R11, AX, BX, CX, DX, R8, R12, R13, R14, DI, R15, SP, 0x4c)
822 LONG $0x24440344; BYTE $0x4c // add r8d,[rsp+0x4c]
823 WORD $0x2141; BYTE $0xdc // and r12d,ebx
824 LONG $0xf07b63c4; WORD $0x19eb // rorx r13d,ebx,0x19
825 LONG $0xf07be3c4; WORD $0x0bfb // rorx edi,ebx,0xb
826 LONG $0x310c8d47 // lea r9d,[r9+r14*1]
827 LONG $0x20048d47 // lea r8d,[r8+r12*1]
828 LONG $0xf26062c4; BYTE $0xe2 // andn r12d,ebx,edx
829 WORD $0x3141; BYTE $0xfd // xor r13d,edi
830 LONG $0xf07b63c4; WORD $0x06f3 // rorx r14d,ebx,0x6
831 LONG $0x20048d47 // lea r8d,[r8+r12*1]
832 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
833 WORD $0x8944; BYTE $0xcf // mov edi,r9d
834 LONG $0xf07b43c4; WORD $0x16e1 // rorx r12d,r9d,0x16
835 LONG $0x28048d47 // lea r8d,[r8+r13*1]
836 WORD $0x3144; BYTE $0xd7 // xor edi,r10d
837 LONG $0xf07b43c4; WORD $0x0df1 // rorx r14d,r9d,0xd
838 LONG $0xf07b43c4; WORD $0x02e9 // rorx r13d,r9d,0x2
839 LONG $0x00048d42 // lea eax,[rax+r8*1]
840 WORD $0x2141; BYTE $0xff // and r15d,edi
841 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
842 WORD $0x3145; BYTE $0xd7 // xor r15d,r10d
843 WORD $0x3145; BYTE $0xee // xor r14d,r13d
844 LONG $0x38048d47 // lea r8d,[r8+r15*1]
845 WORD $0x8941; BYTE $0xdc // mov r12d,ebx
846
847 // ROUND(R8, R9, R10, R11, AX, BX, CX, DX, R12, R13, R14, R15, DI, SP, 0x60)
848 LONG $0x60245403 // add edx,[rsp+0x60]
849 WORD $0x2141; BYTE $0xc4 // and r12d,eax
850 LONG $0xf07b63c4; WORD $0x19e8 // rorx r13d,eax,0x19
851 LONG $0xf07b63c4; WORD $0x0bf8 // rorx r15d,eax,0xb
852 LONG $0x30048d47 // lea r8d,[r8+r14*1]
853 LONG $0x22148d42 // lea edx,[rdx+r12*1]
854 LONG $0xf27862c4; BYTE $0xe1 // andn r12d,eax,ecx
855 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
856 LONG $0xf07b63c4; WORD $0x06f0 // rorx r14d,eax,0x6
857 LONG $0x22148d42 // lea edx,[rdx+r12*1]
858 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
859 WORD $0x8945; BYTE $0xc7 // mov r15d,r8d
860 LONG $0xf07b43c4; WORD $0x16e0 // rorx r12d,r8d,0x16
861 LONG $0x2a148d42 // lea edx,[rdx+r13*1]
862 WORD $0x3145; BYTE $0xcf // xor r15d,r9d
863 LONG $0xf07b43c4; WORD $0x0df0 // rorx r14d,r8d,0xd
864 LONG $0xf07b43c4; WORD $0x02e8 // rorx r13d,r8d,0x2
865 LONG $0x131c8d45 // lea r11d,[r11+rdx*1]
866 WORD $0x2144; BYTE $0xff // and edi,r15d
867 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
868 WORD $0x3144; BYTE $0xcf // xor edi,r9d
869 WORD $0x3145; BYTE $0xee // xor r14d,r13d
870 WORD $0x148d; BYTE $0x3a // lea edx,[rdx+rdi*1]
871 WORD $0x8941; BYTE $0xc4 // mov r12d,eax
872
873 // ROUND(DX, R8, R9, R10, R11, AX, BX, CX, R12, R13, R14, DI, R15, SP, 0x64)
874 LONG $0x64244c03 // add ecx,[rsp+0x64]
875 WORD $0x2145; BYTE $0xdc // and r12d,r11d
876 LONG $0xf07b43c4; WORD $0x19eb // rorx r13d,r11d,0x19
877 LONG $0xf07bc3c4; WORD $0x0bfb // rorx edi,r11d,0xb
878 LONG $0x32148d42 // lea edx,[rdx+r14*1]
879 LONG $0x210c8d42 // lea ecx,[rcx+r12*1]
880 LONG $0xf22062c4; BYTE $0xe3 // andn r12d,r11d,ebx
881 WORD $0x3141; BYTE $0xfd // xor r13d,edi
882 LONG $0xf07b43c4; WORD $0x06f3 // rorx r14d,r11d,0x6
883 LONG $0x210c8d42 // lea ecx,[rcx+r12*1]
884 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
885 WORD $0xd789 // mov edi,edx
886 LONG $0xf07b63c4; WORD $0x16e2 // rorx r12d,edx,0x16
887 LONG $0x290c8d42 // lea ecx,[rcx+r13*1]
888 WORD $0x3144; BYTE $0xc7 // xor edi,r8d
889 LONG $0xf07b63c4; WORD $0x0df2 // rorx r14d,edx,0xd
890 LONG $0xf07b63c4; WORD $0x02ea // rorx r13d,edx,0x2
891 LONG $0x0a148d45 // lea r10d,[r10+rcx*1]
892 WORD $0x2141; BYTE $0xff // and r15d,edi
893 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
894 WORD $0x3145; BYTE $0xc7 // xor r15d,r8d
895 WORD $0x3145; BYTE $0xee // xor r14d,r13d
896 LONG $0x390c8d42 // lea ecx,[rcx+r15*1]
897 WORD $0x8945; BYTE $0xdc // mov r12d,r11d
898
899 // ROUND(CX, DX, R8, R9, R10, R11, AX, BX, R12, R13, R14, R15, DI, SP, 0x68)
900 LONG $0x68245c03 // add ebx,[rsp+0x68]
901 WORD $0x2145; BYTE $0xd4 // and r12d,r10d
902 LONG $0xf07b43c4; WORD $0x19ea // rorx r13d,r10d,0x19
903 LONG $0xf07b43c4; WORD $0x0bfa // rorx r15d,r10d,0xb
904 LONG $0x310c8d42 // lea ecx,[rcx+r14*1]
905 LONG $0x231c8d42 // lea ebx,[rbx+r12*1]
906 LONG $0xf22862c4; BYTE $0xe0 // andn r12d,r10d,eax
907 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
908 LONG $0xf07b43c4; WORD $0x06f2 // rorx r14d,r10d,0x6
909 LONG $0x231c8d42 // lea ebx,[rbx+r12*1]
910 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
911 WORD $0x8941; BYTE $0xcf // mov r15d,ecx
912 LONG $0xf07b63c4; WORD $0x16e1 // rorx r12d,ecx,0x16
913 LONG $0x2b1c8d42 // lea ebx,[rbx+r13*1]
914 WORD $0x3141; BYTE $0xd7 // xor r15d,edx
915 LONG $0xf07b63c4; WORD $0x0df1 // rorx r14d,ecx,0xd
916 LONG $0xf07b63c4; WORD $0x02e9 // rorx r13d,ecx,0x2
917 LONG $0x190c8d45 // lea r9d,[r9+rbx*1]
918 WORD $0x2144; BYTE $0xff // and edi,r15d
919 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
920 WORD $0xd731 // xor edi,edx
921 WORD $0x3145; BYTE $0xee // xor r14d,r13d
922 WORD $0x1c8d; BYTE $0x3b // lea ebx,[rbx+rdi*1]
923 WORD $0x8945; BYTE $0xd4 // mov r12d,r10d
924
925 // ROUND(BX, CX, DX, R8, R9, R10, R11, AX, R12, R13, R14, DI, R15, SP, 0x6c)
926 LONG $0x6c244403 // add eax,[rsp+0x6c]
927 WORD $0x2145; BYTE $0xcc // and r12d,r9d
928 LONG $0xf07b43c4; WORD $0x19e9 // rorx r13d,r9d,0x19
929 LONG $0xf07bc3c4; WORD $0x0bf9 // rorx edi,r9d,0xb
930 LONG $0x331c8d42 // lea ebx,[rbx+r14*1]
931 LONG $0x20048d42 // lea eax,[rax+r12*1]
932 LONG $0xf23042c4; BYTE $0xe3 // andn r12d,r9d,r11d
933 WORD $0x3141; BYTE $0xfd // xor r13d,edi
934 LONG $0xf07b43c4; WORD $0x06f1 // rorx r14d,r9d,0x6
935 LONG $0x20048d42 // lea eax,[rax+r12*1]
936 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
937 WORD $0xdf89 // mov edi,ebx
938 LONG $0xf07b63c4; WORD $0x16e3 // rorx r12d,ebx,0x16
939 LONG $0x28048d42 // lea eax,[rax+r13*1]
940 WORD $0xcf31 // xor edi,ecx
941 LONG $0xf07b63c4; WORD $0x0df3 // rorx r14d,ebx,0xd
942 LONG $0xf07b63c4; WORD $0x02eb // rorx r13d,ebx,0x2
943 LONG $0x00048d45 // lea r8d,[r8+rax*1]
944 WORD $0x2141; BYTE $0xff // and r15d,edi
945 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
946 WORD $0x3141; BYTE $0xcf // xor r15d,ecx
947 WORD $0x3145; BYTE $0xee // xor r14d,r13d
948 LONG $0x38048d42 // lea eax,[rax+r15*1]
949 WORD $0x8945; BYTE $0xcc // mov r12d,r9d
950
951 // ROUND(AX, BX, CX, DX, R8, R9, R10, R11, R12, R13, R14, R15, DI, SP, 0x00)
952 LONG $0x241c0344 // add r11d,[rsp]
953 WORD $0x2145; BYTE $0xc4 // and r12d,r8d
954 LONG $0xf07b43c4; WORD $0x19e8 // rorx r13d,r8d,0x19
955 LONG $0xf07b43c4; WORD $0x0bf8 // rorx r15d,r8d,0xb
956 LONG $0x30048d42 // lea eax,[rax+r14*1]
957 LONG $0x231c8d47 // lea r11d,[r11+r12*1]
958 LONG $0xf23842c4; BYTE $0xe2 // andn r12d,r8d,r10d
959 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
960 LONG $0xf07b43c4; WORD $0x06f0 // rorx r14d,r8d,0x6
961 LONG $0x231c8d47 // lea r11d,[r11+r12*1]
962 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
963 WORD $0x8941; BYTE $0xc7 // mov r15d,eax
964 LONG $0xf07b63c4; WORD $0x16e0 // rorx r12d,eax,0x16
965 LONG $0x2b1c8d47 // lea r11d,[r11+r13*1]
966 WORD $0x3141; BYTE $0xdf // xor r15d,ebx
967 LONG $0xf07b63c4; WORD $0x0df0 // rorx r14d,eax,0xd
968 LONG $0xf07b63c4; WORD $0x02e8 // rorx r13d,eax,0x2
969 LONG $0x1a148d42 // lea edx,[rdx+r11*1]
970 WORD $0x2144; BYTE $0xff // and edi,r15d
971 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
972 WORD $0xdf31 // xor edi,ebx
973 WORD $0x3145; BYTE $0xee // xor r14d,r13d
974 LONG $0x3b1c8d45 // lea r11d,[r11+rdi*1]
975 WORD $0x8945; BYTE $0xc4 // mov r12d,r8d
976
977 // ROUND(R11, AX, BX, CX, DX, R8, R9, R10, R12, R13, R14, DI, R15, SP, 0x04)
978 LONG $0x24540344; BYTE $0x04 // add r10d,[rsp+0x4]
979 WORD $0x2141; BYTE $0xd4 // and r12d,edx
980 LONG $0xf07b63c4; WORD $0x19ea // rorx r13d,edx,0x19
981 LONG $0xf07be3c4; WORD $0x0bfa // rorx edi,edx,0xb
982 LONG $0x331c8d47 // lea r11d,[r11+r14*1]
983 LONG $0x22148d47 // lea r10d,[r10+r12*1]
984 LONG $0xf26842c4; BYTE $0xe1 // andn r12d,edx,r9d
985 WORD $0x3141; BYTE $0xfd // xor r13d,edi
986 LONG $0xf07b63c4; WORD $0x06f2 // rorx r14d,edx,0x6
987 LONG $0x22148d47 // lea r10d,[r10+r12*1]
988 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
989 WORD $0x8944; BYTE $0xdf // mov edi,r11d
990 LONG $0xf07b43c4; WORD $0x16e3 // rorx r12d,r11d,0x16
991 LONG $0x2a148d47 // lea r10d,[r10+r13*1]
992 WORD $0xc731 // xor edi,eax
993 LONG $0xf07b43c4; WORD $0x0df3 // rorx r14d,r11d,0xd
994 LONG $0xf07b43c4; WORD $0x02eb // rorx r13d,r11d,0x2
995 LONG $0x110c8d42 // lea ecx,[rcx+r10*1]
996 WORD $0x2141; BYTE $0xff // and r15d,edi
997 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
998 WORD $0x3141; BYTE $0xc7 // xor r15d,eax
999 WORD $0x3145; BYTE $0xee // xor r14d,r13d
1000 LONG $0x3a148d47 // lea r10d,[r10+r15*1]
1001 WORD $0x8941; BYTE $0xd4 // mov r12d,edx
1002
1003 // ROUND(R10, R11, AX, BX, CX, DX, R8, R9, R12, R13, R14, R15, DI, SP, 0x08)
1004 LONG $0x244c0344; BYTE $0x08 // add r9d,[rsp+0x8]
1005 WORD $0x2141; BYTE $0xcc // and r12d,ecx
1006 LONG $0xf07b63c4; WORD $0x19e9 // rorx r13d,ecx,0x19
1007 LONG $0xf07b63c4; WORD $0x0bf9 // rorx r15d,ecx,0xb
1008 LONG $0x32148d47 // lea r10d,[r10+r14*1]
1009 LONG $0x210c8d47 // lea r9d,[r9+r12*1]
1010 LONG $0xf27042c4; BYTE $0xe0 // andn r12d,ecx,r8d
1011 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
1012 LONG $0xf07b63c4; WORD $0x06f1 // rorx r14d,ecx,0x6
1013 LONG $0x210c8d47 // lea r9d,[r9+r12*1]
1014 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
1015 WORD $0x8945; BYTE $0xd7 // mov r15d,r10d
1016 LONG $0xf07b43c4; WORD $0x16e2 // rorx r12d,r10d,0x16
1017 LONG $0x290c8d47 // lea r9d,[r9+r13*1]
1018 WORD $0x3145; BYTE $0xdf // xor r15d,r11d
1019 LONG $0xf07b43c4; WORD $0x0df2 // rorx r14d,r10d,0xd
1020 LONG $0xf07b43c4; WORD $0x02ea // rorx r13d,r10d,0x2
1021 LONG $0x0b1c8d42 // lea ebx,[rbx+r9*1]
1022 WORD $0x2144; BYTE $0xff // and edi,r15d
1023 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
1024 WORD $0x3144; BYTE $0xdf // xor edi,r11d
1025 WORD $0x3145; BYTE $0xee // xor r14d,r13d
1026 LONG $0x390c8d45 // lea r9d,[r9+rdi*1]
1027 WORD $0x8941; BYTE $0xcc // mov r12d,ecx
1028
1029 // ROUND(R9, R10, R11, AX, BX, CX, DX, R8, R12, R13, R14, DI, R15, SP, 0x0c)
1030 LONG $0x24440344; BYTE $0x0c // add r8d,[rsp+0xc]
1031 WORD $0x2141; BYTE $0xdc // and r12d,ebx
1032 LONG $0xf07b63c4; WORD $0x19eb // rorx r13d,ebx,0x19
1033 LONG $0xf07be3c4; WORD $0x0bfb // rorx edi,ebx,0xb
1034 LONG $0x310c8d47 // lea r9d,[r9+r14*1]
1035 LONG $0x20048d47 // lea r8d,[r8+r12*1]
1036 LONG $0xf26062c4; BYTE $0xe2 // andn r12d,ebx,edx
1037 WORD $0x3141; BYTE $0xfd // xor r13d,edi
1038 LONG $0xf07b63c4; WORD $0x06f3 // rorx r14d,ebx,0x6
1039 LONG $0x20048d47 // lea r8d,[r8+r12*1]
1040 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
1041 WORD $0x8944; BYTE $0xcf // mov edi,r9d
1042 LONG $0xf07b43c4; WORD $0x16e1 // rorx r12d,r9d,0x16
1043 LONG $0x28048d47 // lea r8d,[r8+r13*1]
1044 WORD $0x3144; BYTE $0xd7 // xor edi,r10d
1045 LONG $0xf07b43c4; WORD $0x0df1 // rorx r14d,r9d,0xd
1046 LONG $0xf07b43c4; WORD $0x02e9 // rorx r13d,r9d,0x2
1047 LONG $0x00048d42 // lea eax,[rax+r8*1]
1048 WORD $0x2141; BYTE $0xff // and r15d,edi
1049 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
1050 WORD $0x3145; BYTE $0xd7 // xor r15d,r10d
1051 WORD $0x3145; BYTE $0xee // xor r14d,r13d
1052 LONG $0x38048d47 // lea r8d,[r8+r15*1]
1053 WORD $0x8941; BYTE $0xdc // mov r12d,ebx
1054
1055 // ROUND(R8, R9, R10, R11, AX, BX, CX, DX, R12, R13, R14, R15, DI, SP, 0x20)
1056 LONG $0x20245403 // add edx,[rsp+0x20]
1057 WORD $0x2141; BYTE $0xc4 // and r12d,eax
1058 LONG $0xf07b63c4; WORD $0x19e8 // rorx r13d,eax,0x19
1059 LONG $0xf07b63c4; WORD $0x0bf8 // rorx r15d,eax,0xb
1060 LONG $0x30048d47 // lea r8d,[r8+r14*1]
1061 LONG $0x22148d42 // lea edx,[rdx+r12*1]
1062 LONG $0xf27862c4; BYTE $0xe1 // andn r12d,eax,ecx
1063 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
1064 LONG $0xf07b63c4; WORD $0x06f0 // rorx r14d,eax,0x6
1065 LONG $0x22148d42 // lea edx,[rdx+r12*1]
1066 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
1067 WORD $0x8945; BYTE $0xc7 // mov r15d,r8d
1068 LONG $0xf07b43c4; WORD $0x16e0 // rorx r12d,r8d,0x16
1069 LONG $0x2a148d42 // lea edx,[rdx+r13*1]
1070 WORD $0x3145; BYTE $0xcf // xor r15d,r9d
1071 LONG $0xf07b43c4; WORD $0x0df0 // rorx r14d,r8d,0xd
1072 LONG $0xf07b43c4; WORD $0x02e8 // rorx r13d,r8d,0x2
1073 LONG $0x131c8d45 // lea r11d,[r11+rdx*1]
1074 WORD $0x2144; BYTE $0xff // and edi,r15d
1075 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
1076 WORD $0x3144; BYTE $0xcf // xor edi,r9d
1077 WORD $0x3145; BYTE $0xee // xor r14d,r13d
1078 WORD $0x148d; BYTE $0x3a // lea edx,[rdx+rdi*1]
1079 WORD $0x8941; BYTE $0xc4 // mov r12d,eax
1080
1081 // ROUND(DX, R8, R9, R10, R11, AX, BX, CX, R12, R13, R14, DI, R15, SP, 0x24)
1082 LONG $0x24244c03 // add ecx,[rsp+0x24]
1083 WORD $0x2145; BYTE $0xdc // and r12d,r11d
1084 LONG $0xf07b43c4; WORD $0x19eb // rorx r13d,r11d,0x19
1085 LONG $0xf07bc3c4; WORD $0x0bfb // rorx edi,r11d,0xb
1086 LONG $0x32148d42 // lea edx,[rdx+r14*1]
1087 LONG $0x210c8d42 // lea ecx,[rcx+r12*1]
1088 LONG $0xf22062c4; BYTE $0xe3 // andn r12d,r11d,ebx
1089 WORD $0x3141; BYTE $0xfd // xor r13d,edi
1090 LONG $0xf07b43c4; WORD $0x06f3 // rorx r14d,r11d,0x6
1091 LONG $0x210c8d42 // lea ecx,[rcx+r12*1]
1092 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
1093 WORD $0xd789 // mov edi,edx
1094 LONG $0xf07b63c4; WORD $0x16e2 // rorx r12d,edx,0x16
1095 LONG $0x290c8d42 // lea ecx,[rcx+r13*1]
1096 WORD $0x3144; BYTE $0xc7 // xor edi,r8d
1097 LONG $0xf07b63c4; WORD $0x0df2 // rorx r14d,edx,0xd
1098 LONG $0xf07b63c4; WORD $0x02ea // rorx r13d,edx,0x2
1099 LONG $0x0a148d45 // lea r10d,[r10+rcx*1]
1100 WORD $0x2141; BYTE $0xff // and r15d,edi
1101 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
1102 WORD $0x3145; BYTE $0xc7 // xor r15d,r8d
1103 WORD $0x3145; BYTE $0xee // xor r14d,r13d
1104 LONG $0x390c8d42 // lea ecx,[rcx+r15*1]
1105 WORD $0x8945; BYTE $0xdc // mov r12d,r11d
1106
1107 // ROUND(CX, DX, R8, R9, R10, R11, AX, BX, R12, R13, R14, R15, DI, SP, 0x28)
1108 LONG $0x28245c03 // add ebx,[rsp+0x28]
1109 WORD $0x2145; BYTE $0xd4 // and r12d,r10d
1110 LONG $0xf07b43c4; WORD $0x19ea // rorx r13d,r10d,0x19
1111 LONG $0xf07b43c4; WORD $0x0bfa // rorx r15d,r10d,0xb
1112 LONG $0x310c8d42 // lea ecx,[rcx+r14*1]
1113 LONG $0x231c8d42 // lea ebx,[rbx+r12*1]
1114 LONG $0xf22862c4; BYTE $0xe0 // andn r12d,r10d,eax
1115 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
1116 LONG $0xf07b43c4; WORD $0x06f2 // rorx r14d,r10d,0x6
1117 LONG $0x231c8d42 // lea ebx,[rbx+r12*1]
1118 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
1119 WORD $0x8941; BYTE $0xcf // mov r15d,ecx
1120 LONG $0xf07b63c4; WORD $0x16e1 // rorx r12d,ecx,0x16
1121 LONG $0x2b1c8d42 // lea ebx,[rbx+r13*1]
1122 WORD $0x3141; BYTE $0xd7 // xor r15d,edx
1123 LONG $0xf07b63c4; WORD $0x0df1 // rorx r14d,ecx,0xd
1124 LONG $0xf07b63c4; WORD $0x02e9 // rorx r13d,ecx,0x2
1125 LONG $0x190c8d45 // lea r9d,[r9+rbx*1]
1126 WORD $0x2144; BYTE $0xff // and edi,r15d
1127 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
1128 WORD $0xd731 // xor edi,edx
1129 WORD $0x3145; BYTE $0xee // xor r14d,r13d
1130 WORD $0x1c8d; BYTE $0x3b // lea ebx,[rbx+rdi*1]
1131 WORD $0x8945; BYTE $0xd4 // mov r12d,r10d
1132
1133 // ROUND(BX, CX, DX, R8, R9, R10, R11, AX, R12, R13, R14, DI, R15, SP, 0x2c)
1134 LONG $0x2c244403 // add eax,[rsp+0x2c]
1135 WORD $0x2145; BYTE $0xcc // and r12d,r9d
1136 LONG $0xf07b43c4; WORD $0x19e9 // rorx r13d,r9d,0x19
1137 LONG $0xf07bc3c4; WORD $0x0bf9 // rorx edi,r9d,0xb
1138 LONG $0x331c8d42 // lea ebx,[rbx+r14*1]
1139 LONG $0x20048d42 // lea eax,[rax+r12*1]
1140 LONG $0xf23042c4; BYTE $0xe3 // andn r12d,r9d,r11d
1141 WORD $0x3141; BYTE $0xfd // xor r13d,edi
1142 LONG $0xf07b43c4; WORD $0x06f1 // rorx r14d,r9d,0x6
1143 LONG $0x20048d42 // lea eax,[rax+r12*1]
1144 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
1145 WORD $0xdf89 // mov edi,ebx
1146 LONG $0xf07b63c4; WORD $0x16e3 // rorx r12d,ebx,0x16
1147 LONG $0x28048d42 // lea eax,[rax+r13*1]
1148 WORD $0xcf31 // xor edi,ecx
1149 LONG $0xf07b63c4; WORD $0x0df3 // rorx r14d,ebx,0xd
1150 LONG $0xf07b63c4; WORD $0x02eb // rorx r13d,ebx,0x2
1151 LONG $0x00048d45 // lea r8d,[r8+rax*1]
1152 WORD $0x2141; BYTE $0xff // and r15d,edi
1153 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
1154 WORD $0x3141; BYTE $0xcf // xor r15d,ecx
1155 WORD $0x3145; BYTE $0xee // xor r14d,r13d
1156 LONG $0x38048d42 // lea eax,[rax+r15*1]
1157 WORD $0x8945; BYTE $0xcc // mov r12d,r9d
1158
1159 MOVQ 0x200(SP), DI // $_ctx
1160 ADDQ R14, AX
1161
1162 LEAQ 0x1c0(SP), BP
1163
1164 ADDL (DI), AX
1165 ADDL 4(DI), BX
1166 ADDL 8(DI), CX
1167 ADDL 12(DI), DX
1168 ADDL 16(DI), R8
1169 ADDL 20(DI), R9
1170 ADDL 24(DI), R10
1171 ADDL 28(DI), R11
1172
1173 MOVL AX, (DI)
1174 MOVL BX, 4(DI)
1175 MOVL CX, 8(DI)
1176 MOVL DX, 12(DI)
1177 MOVL R8, 16(DI)
1178 MOVL R9, 20(DI)
1179 MOVL R10, 24(DI)
1180 MOVL R11, 28(DI)
1181
1182 CMPQ SI, 0x50(BP) // $_end
1183 JE done
1184
1185 XORQ R14, R14
1186 MOVQ BX, DI
1187 XORQ CX, DI // magic
1188 MOVQ R9, R12
1189
1190 loop2:
1191 // ROUND(AX, BX, CX, DX, R8, R9, R10, R11, R12, R13, R14, R15, DI, BP, 0x10)
1192 LONG $0x105d0344 // add r11d,[rbp+0x10]
1193 WORD $0x2145; BYTE $0xc4 // and r12d,r8d
1194 LONG $0xf07b43c4; WORD $0x19e8 // rorx r13d,r8d,0x19
1195 LONG $0xf07b43c4; WORD $0x0bf8 // rorx r15d,r8d,0xb
1196 LONG $0x30048d42 // lea eax,[rax+r14*1]
1197 LONG $0x231c8d47 // lea r11d,[r11+r12*1]
1198 LONG $0xf23842c4; BYTE $0xe2 // andn r12d,r8d,r10d
1199 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
1200 LONG $0xf07b43c4; WORD $0x06f0 // rorx r14d,r8d,0x6
1201 LONG $0x231c8d47 // lea r11d,[r11+r12*1]
1202 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
1203 WORD $0x8941; BYTE $0xc7 // mov r15d,eax
1204 LONG $0xf07b63c4; WORD $0x16e0 // rorx r12d,eax,0x16
1205 LONG $0x2b1c8d47 // lea r11d,[r11+r13*1]
1206 WORD $0x3141; BYTE $0xdf // xor r15d,ebx
1207 LONG $0xf07b63c4; WORD $0x0df0 // rorx r14d,eax,0xd
1208 LONG $0xf07b63c4; WORD $0x02e8 // rorx r13d,eax,0x2
1209 LONG $0x1a148d42 // lea edx,[rdx+r11*1]
1210 WORD $0x2144; BYTE $0xff // and edi,r15d
1211 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
1212 WORD $0xdf31 // xor edi,ebx
1213 WORD $0x3145; BYTE $0xee // xor r14d,r13d
1214 LONG $0x3b1c8d45 // lea r11d,[r11+rdi*1]
1215 WORD $0x8945; BYTE $0xc4 // mov r12d,r8d
1216
1217 // ROUND(R11, AX, BX, CX, DX, R8, R9, R10, R12, R13, R14, DI, R15, BP, 0x14)
1218 LONG $0x14550344 // add r10d,[rbp+0x14]
1219 WORD $0x2141; BYTE $0xd4 // and r12d,edx
1220 LONG $0xf07b63c4; WORD $0x19ea // rorx r13d,edx,0x19
1221 LONG $0xf07be3c4; WORD $0x0bfa // rorx edi,edx,0xb
1222 LONG $0x331c8d47 // lea r11d,[r11+r14*1]
1223 LONG $0x22148d47 // lea r10d,[r10+r12*1]
1224 LONG $0xf26842c4; BYTE $0xe1 // andn r12d,edx,r9d
1225 WORD $0x3141; BYTE $0xfd // xor r13d,edi
1226 LONG $0xf07b63c4; WORD $0x06f2 // rorx r14d,edx,0x6
1227 LONG $0x22148d47 // lea r10d,[r10+r12*1]
1228 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
1229 WORD $0x8944; BYTE $0xdf // mov edi,r11d
1230 LONG $0xf07b43c4; WORD $0x16e3 // rorx r12d,r11d,0x16
1231 LONG $0x2a148d47 // lea r10d,[r10+r13*1]
1232 WORD $0xc731 // xor edi,eax
1233 LONG $0xf07b43c4; WORD $0x0df3 // rorx r14d,r11d,0xd
1234 LONG $0xf07b43c4; WORD $0x02eb // rorx r13d,r11d,0x2
1235 LONG $0x110c8d42 // lea ecx,[rcx+r10*1]
1236 WORD $0x2141; BYTE $0xff // and r15d,edi
1237 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
1238 WORD $0x3141; BYTE $0xc7 // xor r15d,eax
1239 WORD $0x3145; BYTE $0xee // xor r14d,r13d
1240 LONG $0x3a148d47 // lea r10d,[r10+r15*1]
1241 WORD $0x8941; BYTE $0xd4 // mov r12d,edx
1242
1243 // ROUND(R10, R11, AX, BX, CX, DX, R8, R9, R12, R13, R14, R15, DI, BP, 0x18)
1244 LONG $0x184d0344 // add r9d,[rbp+0x18]
1245 WORD $0x2141; BYTE $0xcc // and r12d,ecx
1246 LONG $0xf07b63c4; WORD $0x19e9 // rorx r13d,ecx,0x19
1247 LONG $0xf07b63c4; WORD $0x0bf9 // rorx r15d,ecx,0xb
1248 LONG $0x32148d47 // lea r10d,[r10+r14*1]
1249 LONG $0x210c8d47 // lea r9d,[r9+r12*1]
1250 LONG $0xf27042c4; BYTE $0xe0 // andn r12d,ecx,r8d
1251 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
1252 LONG $0xf07b63c4; WORD $0x06f1 // rorx r14d,ecx,0x6
1253 LONG $0x210c8d47 // lea r9d,[r9+r12*1]
1254 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
1255 WORD $0x8945; BYTE $0xd7 // mov r15d,r10d
1256 LONG $0xf07b43c4; WORD $0x16e2 // rorx r12d,r10d,0x16
1257 LONG $0x290c8d47 // lea r9d,[r9+r13*1]
1258 WORD $0x3145; BYTE $0xdf // xor r15d,r11d
1259 LONG $0xf07b43c4; WORD $0x0df2 // rorx r14d,r10d,0xd
1260 LONG $0xf07b43c4; WORD $0x02ea // rorx r13d,r10d,0x2
1261 LONG $0x0b1c8d42 // lea ebx,[rbx+r9*1]
1262 WORD $0x2144; BYTE $0xff // and edi,r15d
1263 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
1264 WORD $0x3144; BYTE $0xdf // xor edi,r11d
1265 WORD $0x3145; BYTE $0xee // xor r14d,r13d
1266 LONG $0x390c8d45 // lea r9d,[r9+rdi*1]
1267 WORD $0x8941; BYTE $0xcc // mov r12d,ecx
1268
1269 // ROUND(R9, R10, R11, AX, BX, CX, DX, R8, R12, R13, R14, DI, R15, BP, 0x1c)
1270 LONG $0x1c450344 // add r8d,[rbp+0x1c]
1271 WORD $0x2141; BYTE $0xdc // and r12d,ebx
1272 LONG $0xf07b63c4; WORD $0x19eb // rorx r13d,ebx,0x19
1273 LONG $0xf07be3c4; WORD $0x0bfb // rorx edi,ebx,0xb
1274 LONG $0x310c8d47 // lea r9d,[r9+r14*1]
1275 LONG $0x20048d47 // lea r8d,[r8+r12*1]
1276 LONG $0xf26062c4; BYTE $0xe2 // andn r12d,ebx,edx
1277 WORD $0x3141; BYTE $0xfd // xor r13d,edi
1278 LONG $0xf07b63c4; WORD $0x06f3 // rorx r14d,ebx,0x6
1279 LONG $0x20048d47 // lea r8d,[r8+r12*1]
1280 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
1281 WORD $0x8944; BYTE $0xcf // mov edi,r9d
1282 LONG $0xf07b43c4; WORD $0x16e1 // rorx r12d,r9d,0x16
1283 LONG $0x28048d47 // lea r8d,[r8+r13*1]
1284 WORD $0x3144; BYTE $0xd7 // xor edi,r10d
1285 LONG $0xf07b43c4; WORD $0x0df1 // rorx r14d,r9d,0xd
1286 LONG $0xf07b43c4; WORD $0x02e9 // rorx r13d,r9d,0x2
1287 LONG $0x00048d42 // lea eax,[rax+r8*1]
1288 WORD $0x2141; BYTE $0xff // and r15d,edi
1289 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
1290 WORD $0x3145; BYTE $0xd7 // xor r15d,r10d
1291 WORD $0x3145; BYTE $0xee // xor r14d,r13d
1292 LONG $0x38048d47 // lea r8d,[r8+r15*1]
1293 WORD $0x8941; BYTE $0xdc // mov r12d,ebx
1294
1295 // ROUND(R8, R9, R10, R11, AX, BX, CX, DX, R12, R13, R14, R15, DI, BP, 0x30)
1296 WORD $0x5503; BYTE $0x30 // add edx,[rbp+0x30]
1297 WORD $0x2141; BYTE $0xc4 // and r12d,eax
1298 LONG $0xf07b63c4; WORD $0x19e8 // rorx r13d,eax,0x19
1299 LONG $0xf07b63c4; WORD $0x0bf8 // rorx r15d,eax,0xb
1300 LONG $0x30048d47 // lea r8d,[r8+r14*1]
1301 LONG $0x22148d42 // lea edx,[rdx+r12*1]
1302 LONG $0xf27862c4; BYTE $0xe1 // andn r12d,eax,ecx
1303 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
1304 LONG $0xf07b63c4; WORD $0x06f0 // rorx r14d,eax,0x6
1305 LONG $0x22148d42 // lea edx,[rdx+r12*1]
1306 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
1307 WORD $0x8945; BYTE $0xc7 // mov r15d,r8d
1308 LONG $0xf07b43c4; WORD $0x16e0 // rorx r12d,r8d,0x16
1309 LONG $0x2a148d42 // lea edx,[rdx+r13*1]
1310 WORD $0x3145; BYTE $0xcf // xor r15d,r9d
1311 LONG $0xf07b43c4; WORD $0x0df0 // rorx r14d,r8d,0xd
1312 LONG $0xf07b43c4; WORD $0x02e8 // rorx r13d,r8d,0x2
1313 LONG $0x131c8d45 // lea r11d,[r11+rdx*1]
1314 WORD $0x2144; BYTE $0xff // and edi,r15d
1315 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
1316 WORD $0x3144; BYTE $0xcf // xor edi,r9d
1317 WORD $0x3145; BYTE $0xee // xor r14d,r13d
1318 WORD $0x148d; BYTE $0x3a // lea edx,[rdx+rdi*1]
1319 WORD $0x8941; BYTE $0xc4 // mov r12d,eax
1320
1321 // ROUND(DX, R8, R9, R10, R11, AX, BX, CX, R12, R13, R14, DI, R15, BP, 0x34)
1322 WORD $0x4d03; BYTE $0x34 // add ecx,[rbp+0x34]
1323 WORD $0x2145; BYTE $0xdc // and r12d,r11d
1324 LONG $0xf07b43c4; WORD $0x19eb // rorx r13d,r11d,0x19
1325 LONG $0xf07bc3c4; WORD $0x0bfb // rorx edi,r11d,0xb
1326 LONG $0x32148d42 // lea edx,[rdx+r14*1]
1327 LONG $0x210c8d42 // lea ecx,[rcx+r12*1]
1328 LONG $0xf22062c4; BYTE $0xe3 // andn r12d,r11d,ebx
1329 WORD $0x3141; BYTE $0xfd // xor r13d,edi
1330 LONG $0xf07b43c4; WORD $0x06f3 // rorx r14d,r11d,0x6
1331 LONG $0x210c8d42 // lea ecx,[rcx+r12*1]
1332 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
1333 WORD $0xd789 // mov edi,edx
1334 LONG $0xf07b63c4; WORD $0x16e2 // rorx r12d,edx,0x16
1335 LONG $0x290c8d42 // lea ecx,[rcx+r13*1]
1336 WORD $0x3144; BYTE $0xc7 // xor edi,r8d
1337 LONG $0xf07b63c4; WORD $0x0df2 // rorx r14d,edx,0xd
1338 LONG $0xf07b63c4; WORD $0x02ea // rorx r13d,edx,0x2
1339 LONG $0x0a148d45 // lea r10d,[r10+rcx*1]
1340 WORD $0x2141; BYTE $0xff // and r15d,edi
1341 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
1342 WORD $0x3145; BYTE $0xc7 // xor r15d,r8d
1343 WORD $0x3145; BYTE $0xee // xor r14d,r13d
1344 LONG $0x390c8d42 // lea ecx,[rcx+r15*1]
1345 WORD $0x8945; BYTE $0xdc // mov r12d,r11d
1346
1347 // ROUND(CX, DX, R8, R9, R10, R11, AX, BX, R12, R13, R14, R15, DI, BP, 0x38)
1348 WORD $0x5d03; BYTE $0x38 // add ebx,[rbp+0x38]
1349 WORD $0x2145; BYTE $0xd4 // and r12d,r10d
1350 LONG $0xf07b43c4; WORD $0x19ea // rorx r13d,r10d,0x19
1351 LONG $0xf07b43c4; WORD $0x0bfa // rorx r15d,r10d,0xb
1352 LONG $0x310c8d42 // lea ecx,[rcx+r14*1]
1353 LONG $0x231c8d42 // lea ebx,[rbx+r12*1]
1354 LONG $0xf22862c4; BYTE $0xe0 // andn r12d,r10d,eax
1355 WORD $0x3145; BYTE $0xfd // xor r13d,r15d
1356 LONG $0xf07b43c4; WORD $0x06f2 // rorx r14d,r10d,0x6
1357 LONG $0x231c8d42 // lea ebx,[rbx+r12*1]
1358 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
1359 WORD $0x8941; BYTE $0xcf // mov r15d,ecx
1360 LONG $0xf07b63c4; WORD $0x16e1 // rorx r12d,ecx,0x16
1361 LONG $0x2b1c8d42 // lea ebx,[rbx+r13*1]
1362 WORD $0x3141; BYTE $0xd7 // xor r15d,edx
1363 LONG $0xf07b63c4; WORD $0x0df1 // rorx r14d,ecx,0xd
1364 LONG $0xf07b63c4; WORD $0x02e9 // rorx r13d,ecx,0x2
1365 LONG $0x190c8d45 // lea r9d,[r9+rbx*1]
1366 WORD $0x2144; BYTE $0xff // and edi,r15d
1367 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
1368 WORD $0xd731 // xor edi,edx
1369 WORD $0x3145; BYTE $0xee // xor r14d,r13d
1370 WORD $0x1c8d; BYTE $0x3b // lea ebx,[rbx+rdi*1]
1371 WORD $0x8945; BYTE $0xd4 // mov r12d,r10d
1372
1373 // ROUND(BX, CX, DX, R8, R9, R10, R11, AX, R12, R13, R14, DI, R15, BP, 0x3c)
1374 WORD $0x4503; BYTE $0x3c // add eax,[rbp+0x3c]
1375 WORD $0x2145; BYTE $0xcc // and r12d,r9d
1376 LONG $0xf07b43c4; WORD $0x19e9 // rorx r13d,r9d,0x19
1377 LONG $0xf07bc3c4; WORD $0x0bf9 // rorx edi,r9d,0xb
1378 LONG $0x331c8d42 // lea ebx,[rbx+r14*1]
1379 LONG $0x20048d42 // lea eax,[rax+r12*1]
1380 LONG $0xf23042c4; BYTE $0xe3 // andn r12d,r9d,r11d
1381 WORD $0x3141; BYTE $0xfd // xor r13d,edi
1382 LONG $0xf07b43c4; WORD $0x06f1 // rorx r14d,r9d,0x6
1383 LONG $0x20048d42 // lea eax,[rax+r12*1]
1384 WORD $0x3145; BYTE $0xf5 // xor r13d,r14d
1385 WORD $0xdf89 // mov edi,ebx
1386 LONG $0xf07b63c4; WORD $0x16e3 // rorx r12d,ebx,0x16
1387 LONG $0x28048d42 // lea eax,[rax+r13*1]
1388 WORD $0xcf31 // xor edi,ecx
1389 LONG $0xf07b63c4; WORD $0x0df3 // rorx r14d,ebx,0xd
1390 LONG $0xf07b63c4; WORD $0x02eb // rorx r13d,ebx,0x2
1391 LONG $0x00048d45 // lea r8d,[r8+rax*1]
1392 WORD $0x2141; BYTE $0xff // and r15d,edi
1393 WORD $0x3145; BYTE $0xe6 // xor r14d,r12d
1394 WORD $0x3141; BYTE $0xcf // xor r15d,ecx
1395 WORD $0x3145; BYTE $0xee // xor r14d,r13d
1396 LONG $0x38048d42 // lea eax,[rax+r15*1]
1397 WORD $0x8945; BYTE $0xcc // mov r12d,r9d
1398
1399 ADDQ $-0x40, BP
1400 CMPQ BP, SP
1401 JAE loop2
1402
1403 MOVQ 0x200(SP), DI // $_ctx
1404 ADDQ R14, AX
1405
1406 ADDQ $0x1c0, SP
1407
1408 ADDL (DI), AX
1409 ADDL 4(DI), BX
1410 ADDL 8(DI), CX
1411 ADDL 12(DI), DX
1412 ADDL 16(DI), R8
1413 ADDL 20(DI), R9
1414
1415 ADDQ $0x80, SI // input += 2
1416 ADDL 24(DI), R10
1417 MOVQ SI, R12
1418 ADDL 28(DI), R11
1419 CMPQ SI, 0x50(SP) // input == _end
1420
1421 MOVL AX, (DI)
1422 LONG $0xe4440f4c // cmove r12,rsp /* next block or stale data */
1423 MOVL AX, (DI)
1424 MOVL BX, 4(DI)
1425 MOVL CX, 8(DI)
1426 MOVL DX, 12(DI)
1427 MOVL R8, 16(DI)
1428 MOVL R9, 20(DI)
1429 MOVL R10, 24(DI)
1430 MOVL R11, 28(DI)
1431
1432 JBE loop0
1433 LEAQ (SP), BP
1434
1435 done:
1436 MOVQ BP, SP
1437 MOVQ 0x58(SP), SP
1438 WORD $0xf8c5; BYTE $0x77 // vzeroupper
1439
1440 RET
1441
0 //+build !noasm
1
2 /*
3 * Minio Cloud Storage, (C) 2016 Minio, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 package sha256
19
20 //go:noescape
21 func blockAvx(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)
0 //+build !noasm !appengine
1
2 // SHA256 implementation for AVX
3
4 //
5 // Minio Cloud Storage, (C) 2016 Minio, Inc.
6 //
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
10 //
11 // http://www.apache.org/licenses/LICENSE-2.0
12 //
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
18 //
19
20 //
21 // This code is based on an Intel White-Paper:
22 // "Fast SHA-256 Implementations on Intel Architecture Processors"
23 //
24 // together with the reference implementation from the following authors:
25 // James Guilford <james.guilford@intel.com>
26 // Kirk Yap <kirk.s.yap@intel.com>
27 // Tim Chen <tim.c.chen@linux.intel.com>
28 //
29 // For Golang it has been converted to Plan 9 assembly with the help of
30 // github.com/minio/asm2plan9s to assemble Intel instructions to their Plan9
31 // equivalents
32 //
33
34 #include "textflag.h"
35
36 #define ROTATE_XS \
37 MOVOU X4, X15 \
38 MOVOU X5, X4 \
39 MOVOU X6, X5 \
40 MOVOU X7, X6 \
41 MOVOU X15, X7
42
43 // compute s0 four at a time and s1 two at a time
44 // compute W[-16] + W[-7] 4 at a time
45 #define FOUR_ROUNDS_AND_SCHED(a, b, c, d, e, f, g, h) \
46 MOVL e, R13 \ /* y0 = e */
47 ROLL $18, R13 \ /* y0 = e >> (25-11) */
48 MOVL a, R14 \ /* y1 = a */
49 LONG $0x0f41e3c4; WORD $0x04c6 \ // VPALIGNR XMM0,XMM7,XMM6,0x4 /* XTMP0 = W[-7] */
50 ROLL $23, R14 \ /* y1 = a >> (22-13) */
51 XORL e, R13 \ /* y0 = e ^ (e >> (25-11)) */
52 MOVL f, R15 \ /* y2 = f */
53 ROLL $27, R13 \ /* y0 = (e >> (11-6)) ^ (e >> (25-6)) */
54 XORL a, R14 \ /* y1 = a ^ (a >> (22-13) */
55 XORL g, R15 \ /* y2 = f^g */
56 LONG $0xc4fef9c5 \ // VPADDD XMM0,XMM0,XMM4 /* XTMP0 = W[-7] + W[-16] */
57 XORL e, R13 \ /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6) ) */
58 ANDL e, R15 \ /* y2 = (f^g)&e */
59 ROLL $21, R14 \ /* y1 = (a >> (13-2)) ^ (a >> (22-2)) */
60 \ /* */
61 \ /* compute s0 */
62 \ /* */
63 LONG $0x0f51e3c4; WORD $0x04cc \ // VPALIGNR XMM1,XMM5,XMM4,0x4 /* XTMP1 = W[-15] */
64 XORL a, R14 \ /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2)) */
65 ROLL $26, R13 \ /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25) */
66 XORL g, R15 \ /* y2 = CH = ((f^g)&e)^g */
67 ROLL $30, R14 \ /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22) */
68 ADDL R13, R15 \ /* y2 = S1 + CH */
69 ADDL _xfer+48(FP), R15 \ /* y2 = k + w + S1 + CH */
70 MOVL a, R13 \ /* y0 = a */
71 ADDL R15, h \ /* h = h + S1 + CH + k + w */
72 \ /* ROTATE_ARGS */
73 MOVL a, R15 \ /* y2 = a */
74 LONG $0xd172e9c5; BYTE $0x07 \ // VPSRLD XMM2,XMM1,0x7 /* */
75 ORL c, R13 \ /* y0 = a|c */
76 ADDL h, d \ /* d = d + h + S1 + CH + k + w */
77 ANDL c, R15 \ /* y2 = a&c */
78 LONG $0xf172e1c5; BYTE $0x19 \ // VPSLLD XMM3,XMM1,0x19 /* */
79 ANDL b, R13 \ /* y0 = (a|c)&b */
80 ADDL R14, h \ /* h = h + S1 + CH + k + w + S0 */
81 LONG $0xdaebe1c5 \ // VPOR XMM3,XMM3,XMM2 /* XTMP1 = W[-15] MY_ROR 7 */
82 ORL R15, R13 \ /* y0 = MAJ = (a|c)&b)|(a&c) */
83 ADDL R13, h \ /* h = h + S1 + CH + k + w + S0 + MAJ */
84 \ /* ROTATE_ARGS */
85 MOVL d, R13 \ /* y0 = e */
86 MOVL h, R14 \ /* y1 = a */
87 ROLL $18, R13 \ /* y0 = e >> (25-11) */
88 XORL d, R13 \ /* y0 = e ^ (e >> (25-11)) */
89 MOVL e, R15 \ /* y2 = f */
90 ROLL $23, R14 \ /* y1 = a >> (22-13) */
91 LONG $0xd172e9c5; BYTE $0x12 \ // VPSRLD XMM2,XMM1,0x12 /* */
92 XORL h, R14 \ /* y1 = a ^ (a >> (22-13) */
93 ROLL $27, R13 \ /* y0 = (e >> (11-6)) ^ (e >> (25-6)) */
94 XORL f, R15 \ /* y2 = f^g */
95 LONG $0xd172b9c5; BYTE $0x03 \ // VPSRLD XMM8,XMM1,0x3 /* XTMP4 = W[-15] >> 3 */
96 ROLL $21, R14 \ /* y1 = (a >> (13-2)) ^ (a >> (22-2)) */
97 XORL d, R13 \ /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6)) */
98 ANDL d, R15 \ /* y2 = (f^g)&e */
99 ROLL $26, R13 \ /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25) */
100 LONG $0xf172f1c5; BYTE $0x0e \ // VPSLLD XMM1,XMM1,0xe /* */
101 XORL h, R14 \ /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2)) */
102 XORL f, R15 \ /* y2 = CH = ((f^g)&e)^g */
103 LONG $0xd9efe1c5 \ // VPXOR XMM3,XMM3,XMM1 /* */
104 ADDL R13, R15 \ /* y2 = S1 + CH */
105 ADDL _xfer+52(FP), R15 \ /* y2 = k + w + S1 + CH */
106 ROLL $30, R14 \ /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22) */
107 LONG $0xdaefe1c5 \ // VPXOR XMM3,XMM3,XMM2 /* XTMP1 = W[-15] MY_ROR 7 ^ W[-15] MY_ROR */
108 MOVL h, R13 \ /* y0 = a */
109 ADDL R15, g \ /* h = h + S1 + CH + k + w */
110 MOVL h, R15 \ /* y2 = a */
111 LONG $0xef61c1c4; BYTE $0xc8 \ // VPXOR XMM1,XMM3,XMM8 /* XTMP1 = s0 */
112 ORL b, R13 \ /* y0 = a|c */
113 ADDL g, c \ /* d = d + h + S1 + CH + k + w */
114 ANDL b, R15 \ /* y2 = a&c */
115 \ /* */
116 \ /* compute low s1 */
117 \ /* */
118 LONG $0xd770f9c5; BYTE $0xfa \ // VPSHUFD XMM2,XMM7,0xfa /* XTMP2 = W[-2] {BBAA} */
119 ANDL a, R13 \ /* y0 = (a|c)&b */
120 ADDL R14, g \ /* h = h + S1 + CH + k + w + S0 */
121 LONG $0xc1fef9c5 \ // VPADDD XMM0,XMM0,XMM1 /* XTMP0 = W[-16] + W[-7] + s0 */
122 ORL R15, R13 \ /* y0 = MAJ = (a|c)&b)|(a&c) */
123 ADDL R13, g \ /* h = h + S1 + CH + k + w + S0 + MAJ */
124 \ /* ROTATE_ARGS */
125 MOVL c, R13 \ /* y0 = e */
126 MOVL g, R14 \ /* y1 = a */
127 ROLL $18, R13 \ /* y0 = e >> (25-11) */
128 XORL c, R13 \ /* y0 = e ^ (e >> (25-11)) */
129 ROLL $23, R14 \ /* y1 = a >> (22-13) */
130 MOVL d, R15 \ /* y2 = f */
131 XORL g, R14 \ /* y1 = a ^ (a >> (22-13) */
132 ROLL $27, R13 \ /* y0 = (e >> (11-6)) ^ (e >> (25-6)) */
133 LONG $0xd272b9c5; BYTE $0x0a \ // VPSRLD XMM8,XMM2,0xa /* XTMP4 = W[-2] >> 10 {BBAA} */
134 XORL e, R15 \ /* y2 = f^g */
135 LONG $0xd273e1c5; BYTE $0x13 \ // VPSRLQ XMM3,XMM2,0x13 /* XTMP3 = W[-2] MY_ROR 19 {xBxA} */
136 XORL c, R13 \ /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6)) */
137 ANDL c, R15 \ /* y2 = (f^g)&e */
138 LONG $0xd273e9c5; BYTE $0x11 \ // VPSRLQ XMM2,XMM2,0x11 /* XTMP2 = W[-2] MY_ROR 17 {xBxA} */
139 ROLL $21, R14 \ /* y1 = (a >> (13-2)) ^ (a >> (22-2)) */
140 XORL g, R14 \ /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2)) */
141 XORL e, R15 \ /* y2 = CH = ((f^g)&e)^g */
142 ROLL $26, R13 \ /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25) */
143 LONG $0xd3efe9c5 \ // VPXOR XMM2,XMM2,XMM3 /* */
144 ADDL R13, R15 \ /* y2 = S1 + CH */
145 ROLL $30, R14 \ /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22) */
146 ADDL _xfer+56(FP), R15 \ /* y2 = k + w + S1 + CH */
147 LONG $0xc2ef39c5 \ // VPXOR XMM8,XMM8,XMM2 /* XTMP4 = s1 {xBxA} */
148 MOVL g, R13 \ /* y0 = a */
149 ADDL R15, f \ /* h = h + S1 + CH + k + w */
150 MOVL g, R15 \ /* y2 = a */
151 LONG $0x003942c4; BYTE $0xc2 \ // VPSHUFB XMM8,XMM8,XMM10 /* XTMP4 = s1 {00BA} */
152 ORL a, R13 \ /* y0 = a|c */
153 ADDL f, b \ /* d = d + h + S1 + CH + k + w */
154 ANDL a, R15 \ /* y2 = a&c */
155 LONG $0xfe79c1c4; BYTE $0xc0 \ // VPADDD XMM0,XMM0,XMM8 /* XTMP0 = {..., ..., W[1], W[0]} */
156 ANDL h, R13 \ /* y0 = (a|c)&b */
157 ADDL R14, f \ /* h = h + S1 + CH + k + w + S0 */
158 \ /* */
159 \ /* compute high s1 */
160 \ /* */
161 LONG $0xd070f9c5; BYTE $0x50 \ // VPSHUFD XMM2,XMM0,0x50 /* XTMP2 = W[-2] {DDCC} */
162 ORL R15, R13 \ /* y0 = MAJ = (a|c)&b)|(a&c) */
163 ADDL R13, f \ /* h = h + S1 + CH + k + w + S0 + MAJ */
164 \ /* ROTATE_ARGS */
165 MOVL b, R13 \ /* y0 = e */
166 ROLL $18, R13 \ /* y0 = e >> (25-11) */
167 MOVL f, R14 \ /* y1 = a */
168 ROLL $23, R14 \ /* y1 = a >> (22-13) */
169 XORL b, R13 \ /* y0 = e ^ (e >> (25-11)) */
170 MOVL c, R15 \ /* y2 = f */
171 ROLL $27, R13 \ /* y0 = (e >> (11-6)) ^ (e >> (25-6)) */
172 LONG $0xd272a1c5; BYTE $0x0a \ // VPSRLD XMM11,XMM2,0xa /* XTMP5 = W[-2] >> 10 {DDCC} */
173 XORL f, R14 \ /* y1 = a ^ (a >> (22-13) */
174 XORL d, R15 \ /* y2 = f^g */
175 LONG $0xd273e1c5; BYTE $0x13 \ // VPSRLQ XMM3,XMM2,0x13 /* XTMP3 = W[-2] MY_ROR 19 {xDxC} */
176 XORL b, R13 \ /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6)) */
177 ANDL b, R15 \ /* y2 = (f^g)&e */
178 ROLL $21, R14 \ /* y1 = (a >> (13-2)) ^ (a >> (22-2)) */
179 LONG $0xd273e9c5; BYTE $0x11 \ // VPSRLQ XMM2,XMM2,0x11 /* XTMP2 = W[-2] MY_ROR 17 {xDxC} */
180 XORL f, R14 \ /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2)) */
181 ROLL $26, R13 \ /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25) */
182 XORL d, R15 \ /* y2 = CH = ((f^g)&e)^g */
183 LONG $0xd3efe9c5 \ // VPXOR XMM2,XMM2,XMM3 /* */
184 ROLL $30, R14 \ /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22) */
185 ADDL R13, R15 \ /* y2 = S1 + CH */
186 ADDL _xfer+60(FP), R15 \ /* y2 = k + w + S1 + CH */
187 LONG $0xdaef21c5 \ // VPXOR XMM11,XMM11,XMM2 /* XTMP5 = s1 {xDxC} */
188 MOVL f, R13 \ /* y0 = a */
189 ADDL R15, e \ /* h = h + S1 + CH + k + w */
190 MOVL f, R15 \ /* y2 = a */
191 LONG $0x002142c4; BYTE $0xdc \ // VPSHUFB XMM11,XMM11,XMM12 /* XTMP5 = s1 {DC00} */
192 ORL h, R13 \ /* y0 = a|c */
193 ADDL e, a \ /* d = d + h + S1 + CH + k + w */
194 ANDL h, R15 \ /* y2 = a&c */
195 LONG $0xe0fea1c5 \ // VPADDD XMM4,XMM11,XMM0 /* X0 = {W[3], W[2], W[1], W[0]} */
196 ANDL g, R13 \ /* y0 = (a|c)&b */
197 ADDL R14, e \ /* h = h + S1 + CH + k + w + S0 */
198 ORL R15, R13 \ /* y0 = MAJ = (a|c)&b)|(a&c) */
199 ADDL R13, e \ /* h = h + S1 + CH + k + w + S0 + MAJ */
200 \ /* ROTATE_ARGS */
201 ROTATE_XS
202
203
204 #define DO_ROUND(a, b, c, d, e, f, g, h, offset) \
205 MOVL e, R13 \ /* y0 = e */
206 ROLL $18, R13 \ /* y0 = e >> (25-11) */
207 MOVL a, R14 \ /* y1 = a */
208 XORL e, R13 \ /* y0 = e ^ (e >> (25-11)) */
209 ROLL $23, R14 \ /* y1 = a >> (22-13) */
210 MOVL f, R15 \ /* y2 = f */
211 XORL a, R14 \ /* y1 = a ^ (a >> (22-13) */
212 ROLL $27, R13 \ /* y0 = (e >> (11-6)) ^ (e >> (25-6)) */
213 XORL g, R15 \ /* y2 = f^g */
214 XORL e, R13 \ /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6)) */
215 ROLL $21, R14 \ /* y1 = (a >> (13-2)) ^ (a >> (22-2)) */
216 ANDL e, R15 \ /* y2 = (f^g)&e */
217 XORL a, R14 \ /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2)) */
218 ROLL $26, R13 \ /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25) */
219 XORL g, R15 \ /* y2 = CH = ((f^g)&e)^g */
220 ADDL R13, R15 \ /* y2 = S1 + CH */
221 ROLL $30, R14 \ /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22) */
222 ADDL _xfer+offset(FP), R15 \ /* y2 = k + w + S1 + CH */
223 MOVL a, R13 \ /* y0 = a */
224 ADDL R15, h \ /* h = h + S1 + CH + k + w */
225 MOVL a, R15 \ /* y2 = a */
226 ORL c, R13 \ /* y0 = a|c */
227 ADDL h, d \ /* d = d + h + S1 + CH + k + w */
228 ANDL c, R15 \ /* y2 = a&c */
229 ANDL b, R13 \ /* y0 = (a|c)&b */
230 ADDL R14, h \ /* h = h + S1 + CH + k + w + S0 */
231 ORL R15, R13 \ /* y0 = MAJ = (a|c)&b)|(a&c) */
232 ADDL R13, h /* h = h + S1 + CH + k + w + S0 + MAJ */
233
234
235 // func blockAvx(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)
236 TEXT ·blockAvx(SB), 7, $0
237
238 MOVQ h+0(FP), SI // SI: &h
239 MOVQ message+24(FP), R8 // &message
240 MOVQ lenmessage+32(FP), R9 // length of message
241 CMPQ R9, $0
242 JEQ done_hash
243 ADDQ R8, R9
244 MOVQ R9, _inp_end+64(FP) // store end of message
245
246 // Register definition
247 // a --> eax
248 // b --> ebx
249 // c --> ecx
250 // d --> r8d
251 // e --> edx
252 // f --> r9d
253 // g --> r10d
254 // h --> r11d
255 //
256 // y0 --> r13d
257 // y1 --> r14d
258 // y2 --> r15d
259
260 MOVL (0*4)(SI), AX // a = H0
261 MOVL (1*4)(SI), BX // b = H1
262 MOVL (2*4)(SI), CX // c = H2
263 MOVL (3*4)(SI), R8 // d = H3
264 MOVL (4*4)(SI), DX // e = H4
265 MOVL (5*4)(SI), R9 // f = H5
266 MOVL (6*4)(SI), R10 // g = H6
267 MOVL (7*4)(SI), R11 // h = H7
268
269 MOVOU bflipMask<>(SB), X13
270 MOVOU shuf00BA<>(SB), X10 // shuffle xBxA -> 00BA
271 MOVOU shufDC00<>(SB), X12 // shuffle xDxC -> DC00
272
273 MOVQ message+24(FP), SI // SI: &message
274
275 loop0:
276 LEAQ constants<>(SB), BP
277
278 // byte swap first 16 dwords
279 MOVOU 0*16(SI), X4
280 LONG $0x0059c2c4; BYTE $0xe5 // VPSHUFB XMM4, XMM4, XMM13
281 MOVOU 1*16(SI), X5
282 LONG $0x0051c2c4; BYTE $0xed // VPSHUFB XMM5, XMM5, XMM13
283 MOVOU 2*16(SI), X6
284 LONG $0x0049c2c4; BYTE $0xf5 // VPSHUFB XMM6, XMM6, XMM13
285 MOVOU 3*16(SI), X7
286 LONG $0x0041c2c4; BYTE $0xfd // VPSHUFB XMM7, XMM7, XMM13
287
288 MOVQ SI, _inp+72(FP)
289 MOVD $0x3, DI
290
291 // schedule 48 input dwords, by doing 3 rounds of 16 each
292 loop1:
293 LONG $0x4dfe59c5; BYTE $0x00 // VPADDD XMM9, XMM4, 0[RBP] /* Add 1st constant to first part of message */
294 MOVOU X9, _xfer+48(FP)
295 FOUR_ROUNDS_AND_SCHED(AX, BX, CX, R8, DX, R9, R10, R11)
296
297 LONG $0x4dfe59c5; BYTE $0x10 // VPADDD XMM9, XMM4, 16[RBP] /* Add 2nd constant to message */
298 MOVOU X9, _xfer+48(FP)
299 FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX, CX, R8)
300
301 LONG $0x4dfe59c5; BYTE $0x20 // VPADDD XMM9, XMM4, 32[RBP] /* Add 3rd constant to message */
302 MOVOU X9, _xfer+48(FP)
303 FOUR_ROUNDS_AND_SCHED(AX, BX, CX, R8, DX, R9, R10, R11)
304
305 LONG $0x4dfe59c5; BYTE $0x30 // VPADDD XMM9, XMM4, 48[RBP] /* Add 4th constant to message */
306 MOVOU X9, _xfer+48(FP)
307 ADDQ $64, BP
308 FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX, CX, R8)
309
310 SUBQ $1, DI
311 JNE loop1
312
313 MOVD $0x2, DI
314 loop2:
315 LONG $0x4dfe59c5; BYTE $0x00 // VPADDD XMM9, XMM4, 0[RBP] /* Add 1st constant to first part of message */
316 MOVOU X9, _xfer+48(FP)
317 DO_ROUND( AX, BX, CX, R8, DX, R9, R10, R11, 48)
318 DO_ROUND(R11, AX, BX, CX, R8, DX, R9, R10, 52)
319 DO_ROUND(R10, R11, AX, BX, CX, R8, DX, R9, 56)
320 DO_ROUND( R9, R10, R11, AX, BX, CX, R8, DX, 60)
321
322 LONG $0x4dfe51c5; BYTE $0x10 // VPADDD XMM9, XMM5, 16[RBP] /* Add 2nd constant to message */
323 MOVOU X9, _xfer+48(FP)
324 ADDQ $32, BP
325 DO_ROUND( DX, R9, R10, R11, AX, BX, CX, R8, 48)
326 DO_ROUND( R8, DX, R9, R10, R11, AX, BX, CX, 52)
327 DO_ROUND( CX, R8, DX, R9, R10, R11, AX, BX, 56)
328 DO_ROUND( BX, CX, R8, DX, R9, R10, R11, AX, 60)
329
330 MOVOU X6, X4
331 MOVOU X7, X5
332
333 SUBQ $1, DI
334 JNE loop2
335
336 MOVQ h+0(FP), SI // SI: &h
337 ADDL (0*4)(SI), AX // H0 = a + H0
338 MOVL AX, (0*4)(SI)
339 ADDL (1*4)(SI), BX // H1 = b + H1
340 MOVL BX, (1*4)(SI)
341 ADDL (2*4)(SI), CX // H2 = c + H2
342 MOVL CX, (2*4)(SI)
343 ADDL (3*4)(SI), R8 // H3 = d + H3
344 MOVL R8, (3*4)(SI)
345 ADDL (4*4)(SI), DX // H4 = e + H4
346 MOVL DX, (4*4)(SI)
347 ADDL (5*4)(SI), R9 // H5 = f + H5
348 MOVL R9, (5*4)(SI)
349 ADDL (6*4)(SI), R10 // H6 = g + H6
350 MOVL R10, (6*4)(SI)
351 ADDL (7*4)(SI), R11 // H7 = h + H7
352 MOVL R11, (7*4)(SI)
353
354 MOVQ _inp+72(FP), SI
355 ADDQ $64, SI
356 CMPQ _inp_end+64(FP), SI
357 JNE loop0
358
359 done_hash:
360 RET
361
362 // Constants table
363 DATA constants<>+0x0(SB)/8, $0x71374491428a2f98
364 DATA constants<>+0x8(SB)/8, $0xe9b5dba5b5c0fbcf
365 DATA constants<>+0x10(SB)/8, $0x59f111f13956c25b
366 DATA constants<>+0x18(SB)/8, $0xab1c5ed5923f82a4
367 DATA constants<>+0x20(SB)/8, $0x12835b01d807aa98
368 DATA constants<>+0x28(SB)/8, $0x550c7dc3243185be
369 DATA constants<>+0x30(SB)/8, $0x80deb1fe72be5d74
370 DATA constants<>+0x38(SB)/8, $0xc19bf1749bdc06a7
371 DATA constants<>+0x40(SB)/8, $0xefbe4786e49b69c1
372 DATA constants<>+0x48(SB)/8, $0x240ca1cc0fc19dc6
373 DATA constants<>+0x50(SB)/8, $0x4a7484aa2de92c6f
374 DATA constants<>+0x58(SB)/8, $0x76f988da5cb0a9dc
375 DATA constants<>+0x60(SB)/8, $0xa831c66d983e5152
376 DATA constants<>+0x68(SB)/8, $0xbf597fc7b00327c8
377 DATA constants<>+0x70(SB)/8, $0xd5a79147c6e00bf3
378 DATA constants<>+0x78(SB)/8, $0x1429296706ca6351
379 DATA constants<>+0x80(SB)/8, $0x2e1b213827b70a85
380 DATA constants<>+0x88(SB)/8, $0x53380d134d2c6dfc
381 DATA constants<>+0x90(SB)/8, $0x766a0abb650a7354
382 DATA constants<>+0x98(SB)/8, $0x92722c8581c2c92e
383 DATA constants<>+0xa0(SB)/8, $0xa81a664ba2bfe8a1
384 DATA constants<>+0xa8(SB)/8, $0xc76c51a3c24b8b70
385 DATA constants<>+0xb0(SB)/8, $0xd6990624d192e819
386 DATA constants<>+0xb8(SB)/8, $0x106aa070f40e3585
387 DATA constants<>+0xc0(SB)/8, $0x1e376c0819a4c116
388 DATA constants<>+0xc8(SB)/8, $0x34b0bcb52748774c
389 DATA constants<>+0xd0(SB)/8, $0x4ed8aa4a391c0cb3
390 DATA constants<>+0xd8(SB)/8, $0x682e6ff35b9cca4f
391 DATA constants<>+0xe0(SB)/8, $0x78a5636f748f82ee
392 DATA constants<>+0xe8(SB)/8, $0x8cc7020884c87814
393 DATA constants<>+0xf0(SB)/8, $0xa4506ceb90befffa
394 DATA constants<>+0xf8(SB)/8, $0xc67178f2bef9a3f7
395
396 DATA bflipMask<>+0x00(SB)/8, $0x0405060700010203
397 DATA bflipMask<>+0x08(SB)/8, $0x0c0d0e0f08090a0b
398
399 DATA shuf00BA<>+0x00(SB)/8, $0x0b0a090803020100
400 DATA shuf00BA<>+0x08(SB)/8, $0xFFFFFFFFFFFFFFFF
401
402 DATA shufDC00<>+0x00(SB)/8, $0xFFFFFFFFFFFFFFFF
403 DATA shufDC00<>+0x08(SB)/8, $0x0b0a090803020100
404
405 GLOBL constants<>(SB), 8, $256
406 GLOBL bflipMask<>(SB), (NOPTR+RODATA), $16
407 GLOBL shuf00BA<>(SB), (NOPTR+RODATA), $16
408 GLOBL shufDC00<>(SB), (NOPTR+RODATA), $16
0 //+build !noasm
1
2 /*
3 * Minio Cloud Storage, (C) 2016 Minio, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 package sha256
19
20 //go:noescape
21 func blockSsse(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)
0 //+build !noasm !appengine
1
2 // SHA256 implementation for SSSE3
3
4 //
5 // Minio Cloud Storage, (C) 2016 Minio, Inc.
6 //
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
10 //
11 // http://www.apache.org/licenses/LICENSE-2.0
12 //
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
18 //
19
20 //
21 // This code is based on an Intel White-Paper:
22 // "Fast SHA-256 Implementations on Intel Architecture Processors"
23 //
24 // together with the reference implementation from the following authors:
25 // James Guilford <james.guilford@intel.com>
26 // Kirk Yap <kirk.s.yap@intel.com>
27 // Tim Chen <tim.c.chen@linux.intel.com>
28 //
29 // For Golang it has been converted to Plan 9 assembly with the help of
30 // github.com/minio/asm2plan9s to assemble Intel instructions to their Plan9
31 // equivalents
32 //
33
34 #include "textflag.h"
35
36 #define ROTATE_XS \
37 MOVOU X4, X15 \
38 MOVOU X5, X4 \
39 MOVOU X6, X5 \
40 MOVOU X7, X6 \
41 MOVOU X15, X7
42
43 // compute s0 four at a time and s1 two at a time
44 // compute W[-16] + W[-7] 4 at a time
45 #define FOUR_ROUNDS_AND_SCHED(a, b, c, d, e, f, g, h) \
46 MOVL e, R13 \ /* y0 = e */
47 ROLL $18, R13 \ /* y0 = e >> (25-11) */
48 MOVL a, R14 \ /* y1 = a */
49 MOVOU X7, X0 \
50 LONG $0x0f3a0f66; WORD $0x04c6 \ // PALIGNR XMM0,XMM6,0x4 /* XTMP0 = W[-7] */
51 ROLL $23, R14 \ /* y1 = a >> (22-13) */
52 XORL e, R13 \ /* y0 = e ^ (e >> (25-11)) */
53 MOVL f, R15 \ /* y2 = f */
54 ROLL $27, R13 \ /* y0 = (e >> (11-6)) ^ (e >> (25-6)) */
55 XORL a, R14 \ /* y1 = a ^ (a >> (22-13) */
56 XORL g, R15 \ /* y2 = f^g */
57 LONG $0xc4fe0f66 \ // PADDD XMM0,XMM4 /* XTMP0 = W[-7] + W[-16] */
58 XORL e, R13 \ /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6) ) */
59 ANDL e, R15 \ /* y2 = (f^g)&e */
60 ROLL $21, R14 \ /* y1 = (a >> (13-2)) ^ (a >> (22-2)) */
61 \ /* */
62 \ /* compute s0 */
63 \ /* */
64 MOVOU X5, X1 \
65 LONG $0x0f3a0f66; WORD $0x04cc \ // PALIGNR XMM1,XMM4,0x4 /* XTMP1 = W[-15] */
66 XORL a, R14 \ /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2)) */
67 ROLL $26, R13 \ /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25) */
68 XORL g, R15 \ /* y2 = CH = ((f^g)&e)^g */
69 ROLL $30, R14 \ /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22) */
70 ADDL R13, R15 \ /* y2 = S1 + CH */
71 ADDL _xfer+48(FP), R15 \ /* y2 = k + w + S1 + CH */
72 MOVL a, R13 \ /* y0 = a */
73 ADDL R15, h \ /* h = h + S1 + CH + k + w */
74 \ /* ROTATE_ARGS */
75 MOVL a, R15 \ /* y2 = a */
76 MOVOU X1, X2 \
77 LONG $0xd2720f66; BYTE $0x07 \ // PSRLD XMM2,0x7 /* */
78 ORL c, R13 \ /* y0 = a|c */
79 ADDL h, d \ /* d = d + h + S1 + CH + k + w */
80 ANDL c, R15 \ /* y2 = a&c */
81 MOVOU X1, X3 \
82 LONG $0xf3720f66; BYTE $0x19 \ // PSLLD XMM3,0x19 /* */
83 ANDL b, R13 \ /* y0 = (a|c)&b */
84 ADDL R14, h \ /* h = h + S1 + CH + k + w + S0 */
85 LONG $0xdaeb0f66 \ // POR XMM3,XMM2 /* XTMP1 = W[-15] MY_ROR 7 */
86 ORL R15, R13 \ /* y0 = MAJ = (a|c)&b)|(a&c) */
87 ADDL R13, h \ /* h = h + S1 + CH + k + w + S0 + MAJ */
88 \ /* ROTATE_ARGS */
89 MOVL d, R13 \ /* y0 = e */
90 MOVL h, R14 \ /* y1 = a */
91 ROLL $18, R13 \ /* y0 = e >> (25-11) */
92 XORL d, R13 \ /* y0 = e ^ (e >> (25-11)) */
93 MOVL e, R15 \ /* y2 = f */
94 ROLL $23, R14 \ /* y1 = a >> (22-13) */
95 MOVOU X1, X2 \
96 LONG $0xd2720f66; BYTE $0x12 \ // PSRLD XMM2,0x12 /* */
97 XORL h, R14 \ /* y1 = a ^ (a >> (22-13) */
98 ROLL $27, R13 \ /* y0 = (e >> (11-6)) ^ (e >> (25-6)) */
99 XORL f, R15 \ /* y2 = f^g */
100 MOVOU X1, X8 \
101 LONG $0x720f4166; WORD $0x03d0 \ // PSRLD XMM8,0x3 /* XTMP4 = W[-15] >> 3 */
102 ROLL $21, R14 \ /* y1 = (a >> (13-2)) ^ (a >> (22-2)) */
103 XORL d, R13 \ /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6)) */
104 ANDL d, R15 \ /* y2 = (f^g)&e */
105 ROLL $26, R13 \ /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25) */
106 LONG $0xf1720f66; BYTE $0x0e \ // PSLLD XMM1,0xe /* */
107 XORL h, R14 \ /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2)) */
108 XORL f, R15 \ /* y2 = CH = ((f^g)&e)^g */
109 LONG $0xd9ef0f66 \ // PXOR XMM3,XMM1 /* */
110 ADDL R13, R15 \ /* y2 = S1 + CH */
111 ADDL _xfer+52(FP), R15 \ /* y2 = k + w + S1 + CH */
112 ROLL $30, R14 \ /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22) */
113 LONG $0xdaef0f66 \ // PXOR XMM3,XMM2 /* XTMP1 = W[-15] MY_ROR 7 ^ W[-15] MY_ROR */
114 MOVL h, R13 \ /* y0 = a */
115 ADDL R15, g \ /* h = h + S1 + CH + k + w */
116 MOVL h, R15 \ /* y2 = a */
117 MOVOU X3, X1 \
118 LONG $0xef0f4166; BYTE $0xc8 \ // PXOR XMM1,XMM8 /* XTMP1 = s0 */
119 ORL b, R13 \ /* y0 = a|c */
120 ADDL g, c \ /* d = d + h + S1 + CH + k + w */
121 ANDL b, R15 \ /* y2 = a&c */
122 \ /* */
123 \ /* compute low s1 */
124 \ /* */
125 LONG $0xd7700f66; BYTE $0xfa \ // PSHUFD XMM2,XMM7,0xfa /* XTMP2 = W[-2] {BBAA} */
126 ANDL a, R13 \ /* y0 = (a|c)&b */
127 ADDL R14, g \ /* h = h + S1 + CH + k + w + S0 */
128 LONG $0xc1fe0f66 \ // PADDD XMM0,XMM1 /* XTMP0 = W[-16] + W[-7] + s0 */
129 ORL R15, R13 \ /* y0 = MAJ = (a|c)&b)|(a&c) */
130 ADDL R13, g \ /* h = h + S1 + CH + k + w + S0 + MAJ */
131 \ /* ROTATE_ARGS */
132 MOVL c, R13 \ /* y0 = e */
133 MOVL g, R14 \ /* y1 = a */
134 ROLL $18, R13 \ /* y0 = e >> (25-11) */
135 XORL c, R13 \ /* y0 = e ^ (e >> (25-11)) */
136 ROLL $23, R14 \ /* y1 = a >> (22-13) */
137 MOVL d, R15 \ /* y2 = f */
138 XORL g, R14 \ /* y1 = a ^ (a >> (22-13) */
139 ROLL $27, R13 \ /* y0 = (e >> (11-6)) ^ (e >> (25-6)) */
140 MOVOU X2, X8 \
141 LONG $0x720f4166; WORD $0x0ad0 \ // PSRLD XMM8,0xa /* XTMP4 = W[-2] >> 10 {BBAA} */
142 XORL e, R15 \ /* y2 = f^g */
143 MOVOU X2, X3 \
144 LONG $0xd3730f66; BYTE $0x13 \ // PSRLQ XMM3,0x13 /* XTMP3 = W[-2] MY_ROR 19 {xBxA} */
145 XORL c, R13 \ /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6)) */
146 ANDL c, R15 \ /* y2 = (f^g)&e */
147 LONG $0xd2730f66; BYTE $0x11 \ // PSRLQ XMM2,0x11 /* XTMP2 = W[-2] MY_ROR 17 {xBxA} */
148 ROLL $21, R14 \ /* y1 = (a >> (13-2)) ^ (a >> (22-2)) */
149 XORL g, R14 \ /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2)) */
150 XORL e, R15 \ /* y2 = CH = ((f^g)&e)^g */
151 ROLL $26, R13 \ /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25) */
152 LONG $0xd3ef0f66 \ // PXOR XMM2,XMM3 /* */
153 ADDL R13, R15 \ /* y2 = S1 + CH */
154 ROLL $30, R14 \ /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22) */
155 ADDL _xfer+56(FP), R15 \ /* y2 = k + w + S1 + CH */
156 LONG $0xef0f4466; BYTE $0xc2 \ // PXOR XMM8,XMM2 /* XTMP4 = s1 {xBxA} */
157 MOVL g, R13 \ /* y0 = a */
158 ADDL R15, f \ /* h = h + S1 + CH + k + w */
159 MOVL g, R15 \ /* y2 = a */
160 LONG $0x380f4566; WORD $0xc200 \ // PSHUFB XMM8,XMM10 /* XTMP4 = s1 {00BA} */
161 ORL a, R13 \ /* y0 = a|c */
162 ADDL f, b \ /* d = d + h + S1 + CH + k + w */
163 ANDL a, R15 \ /* y2 = a&c */
164 LONG $0xfe0f4166; BYTE $0xc0 \ // PADDD XMM0,XMM8 /* XTMP0 = {..., ..., W[1], W[0]} */
165 ANDL h, R13 \ /* y0 = (a|c)&b */
166 ADDL R14, f \ /* h = h + S1 + CH + k + w + S0 */
167 \ /* */
168 \ /* compute high s1 */
169 \ /* */
170 LONG $0xd0700f66; BYTE $0x50 \ // PSHUFD XMM2,XMM0,0x50 /* XTMP2 = W[-2] {DDCC} */
171 ORL R15, R13 \ /* y0 = MAJ = (a|c)&b)|(a&c) */
172 ADDL R13, f \ /* h = h + S1 + CH + k + w + S0 + MAJ */
173 \ /* ROTATE_ARGS */
174 MOVL b, R13 \ /* y0 = e */
175 ROLL $18, R13 \ /* y0 = e >> (25-11) */
176 MOVL f, R14 \ /* y1 = a */
177 ROLL $23, R14 \ /* y1 = a >> (22-13) */
178 XORL b, R13 \ /* y0 = e ^ (e >> (25-11)) */
179 MOVL c, R15 \ /* y2 = f */
180 ROLL $27, R13 \ /* y0 = (e >> (11-6)) ^ (e >> (25-6)) */
181 MOVOU X2, X11 \
182 LONG $0x720f4166; WORD $0x0ad3 \ // PSRLD XMM11,0xa /* XTMP5 = W[-2] >> 10 {DDCC} */
183 XORL f, R14 \ /* y1 = a ^ (a >> (22-13) */
184 XORL d, R15 \ /* y2 = f^g */
185 MOVOU X2, X3 \
186 LONG $0xd3730f66; BYTE $0x13 \ // PSRLQ XMM3,0x13 /* XTMP3 = W[-2] MY_ROR 19 {xDxC} */
187 XORL b, R13 \ /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6)) */
188 ANDL b, R15 \ /* y2 = (f^g)&e */
189 ROLL $21, R14 \ /* y1 = (a >> (13-2)) ^ (a >> (22-2)) */
190 LONG $0xd2730f66; BYTE $0x11 \ // PSRLQ XMM2,0x11 /* XTMP2 = W[-2] MY_ROR 17 {xDxC} */
191 XORL f, R14 \ /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2)) */
192 ROLL $26, R13 \ /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25) */
193 XORL d, R15 \ /* y2 = CH = ((f^g)&e)^g */
194 LONG $0xd3ef0f66 \ // PXOR XMM2,XMM3 /* */
195 ROLL $30, R14 \ /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22) */
196 ADDL R13, R15 \ /* y2 = S1 + CH */
197 ADDL _xfer+60(FP), R15 \ /* y2 = k + w + S1 + CH */
198 LONG $0xef0f4466; BYTE $0xda \ // PXOR XMM11,XMM2 /* XTMP5 = s1 {xDxC} */
199 MOVL f, R13 \ /* y0 = a */
200 ADDL R15, e \ /* h = h + S1 + CH + k + w */
201 MOVL f, R15 \ /* y2 = a */
202 LONG $0x380f4566; WORD $0xdc00 \ // PSHUFB XMM11,XMM12 /* XTMP5 = s1 {DC00} */
203 ORL h, R13 \ /* y0 = a|c */
204 ADDL e, a \ /* d = d + h + S1 + CH + k + w */
205 ANDL h, R15 \ /* y2 = a&c */
206 MOVOU X11, X4 \
207 LONG $0xe0fe0f66 \ // PADDD XMM4,XMM0 /* X0 = {W[3], W[2], W[1], W[0]} */
208 ANDL g, R13 \ /* y0 = (a|c)&b */
209 ADDL R14, e \ /* h = h + S1 + CH + k + w + S0 */
210 ORL R15, R13 \ /* y0 = MAJ = (a|c)&b)|(a&c) */
211 ADDL R13, e \ /* h = h + S1 + CH + k + w + S0 + MAJ */
212 \ /* ROTATE_ARGS */
213 ROTATE_XS
214
215
216 #define DO_ROUND(a, b, c, d, e, f, g, h, offset) \
217 MOVL e, R13 \ /* y0 = e */
218 ROLL $18, R13 \ /* y0 = e >> (25-11) */
219 MOVL a, R14 \ /* y1 = a */
220 XORL e, R13 \ /* y0 = e ^ (e >> (25-11)) */
221 ROLL $23, R14 \ /* y1 = a >> (22-13) */
222 MOVL f, R15 \ /* y2 = f */
223 XORL a, R14 \ /* y1 = a ^ (a >> (22-13) */
224 ROLL $27, R13 \ /* y0 = (e >> (11-6)) ^ (e >> (25-6)) */
225 XORL g, R15 \ /* y2 = f^g */
226 XORL e, R13 \ /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6)) */
227 ROLL $21, R14 \ /* y1 = (a >> (13-2)) ^ (a >> (22-2)) */
228 ANDL e, R15 \ /* y2 = (f^g)&e */
229 XORL a, R14 \ /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2)) */
230 ROLL $26, R13 \ /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25) */
231 XORL g, R15 \ /* y2 = CH = ((f^g)&e)^g */
232 ADDL R13, R15 \ /* y2 = S1 + CH */
233 ROLL $30, R14 \ /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22) */
234 ADDL _xfer+offset(FP), R15 \ /* y2 = k + w + S1 + CH */
235 MOVL a, R13 \ /* y0 = a */
236 ADDL R15, h \ /* h = h + S1 + CH + k + w */
237 MOVL a, R15 \ /* y2 = a */
238 ORL c, R13 \ /* y0 = a|c */
239 ADDL h, d \ /* d = d + h + S1 + CH + k + w */
240 ANDL c, R15 \ /* y2 = a&c */
241 ANDL b, R13 \ /* y0 = (a|c)&b */
242 ADDL R14, h \ /* h = h + S1 + CH + k + w + S0 */
243 ORL R15, R13 \ /* y0 = MAJ = (a|c)&b)|(a&c) */
244 ADDL R13, h /* h = h + S1 + CH + k + w + S0 + MAJ */
245
246
247 // func blockSsse(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)
248 TEXT ·blockSsse(SB), 7, $0
249
250 MOVQ h+0(FP), SI // SI: &h
251 MOVQ message+24(FP), R8 // &message
252 MOVQ lenmessage+32(FP), R9 // length of message
253 CMPQ R9, $0
254 JEQ done_hash
255 ADDQ R8, R9
256 MOVQ R9, _inp_end+64(FP) // store end of message
257
258 // Register definition
259 // a --> eax
260 // b --> ebx
261 // c --> ecx
262 // d --> r8d
263 // e --> edx
264 // f --> r9d
265 // g --> r10d
266 // h --> r11d
267 //
268 // y0 --> r13d
269 // y1 --> r14d
270 // y2 --> r15d
271
272 MOVL (0*4)(SI), AX // a = H0
273 MOVL (1*4)(SI), BX // b = H1
274 MOVL (2*4)(SI), CX // c = H2
275 MOVL (3*4)(SI), R8 // d = H3
276 MOVL (4*4)(SI), DX // e = H4
277 MOVL (5*4)(SI), R9 // f = H5
278 MOVL (6*4)(SI), R10 // g = H6
279 MOVL (7*4)(SI), R11 // h = H7
280
281 MOVOU bflipMask<>(SB), X13
282 MOVOU shuf00BA<>(SB), X10 // shuffle xBxA -> 00BA
283 MOVOU shufDC00<>(SB), X12 // shuffle xDxC -> DC00
284
285 MOVQ message+24(FP), SI // SI: &message
286
287 loop0:
288 LEAQ constants<>(SB), BP
289
290 // byte swap first 16 dwords
291 MOVOU 0*16(SI), X4
292 LONG $0x380f4166; WORD $0xe500 // PSHUFB XMM4, XMM13
293 MOVOU 1*16(SI), X5
294 LONG $0x380f4166; WORD $0xed00 // PSHUFB XMM5, XMM13
295 MOVOU 2*16(SI), X6
296 LONG $0x380f4166; WORD $0xf500 // PSHUFB XMM6, XMM13
297 MOVOU 3*16(SI), X7
298 LONG $0x380f4166; WORD $0xfd00 // PSHUFB XMM7, XMM13
299
300 MOVQ SI, _inp+72(FP)
301 MOVD $0x3, DI
302
303 // Align
304 // nop WORD PTR [rax+rax*1+0x0]
305
306 // schedule 48 input dwords, by doing 3 rounds of 16 each
307 loop1:
308 MOVOU X4, X9
309 LONG $0xfe0f4466; WORD $0x004d // PADDD XMM9, 0[RBP] /* Add 1st constant to first part of message */
310 MOVOU X9, _xfer+48(FP)
311 FOUR_ROUNDS_AND_SCHED(AX, BX, CX, R8, DX, R9, R10, R11)
312
313 MOVOU X4, X9
314 LONG $0xfe0f4466; WORD $0x104d // PADDD XMM9, 16[RBP] /* Add 2nd constant to message */
315 MOVOU X9, _xfer+48(FP)
316 FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX, CX, R8)
317
318 MOVOU X4, X9
319 LONG $0xfe0f4466; WORD $0x204d // PADDD XMM9, 32[RBP] /* Add 3rd constant to message */
320 MOVOU X9, _xfer+48(FP)
321 FOUR_ROUNDS_AND_SCHED(AX, BX, CX, R8, DX, R9, R10, R11)
322
323 MOVOU X4, X9
324 LONG $0xfe0f4466; WORD $0x304d // PADDD XMM9, 48[RBP] /* Add 4th constant to message */
325 MOVOU X9, _xfer+48(FP)
326 ADDQ $64, BP
327 FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX, CX, R8)
328
329 SUBQ $1, DI
330 JNE loop1
331
332 MOVD $0x2, DI
333 loop2:
334 MOVOU X4, X9
335 LONG $0xfe0f4466; WORD $0x004d // PADDD XMM9, 0[RBP] /* Add 1st constant to first part of message */
336 MOVOU X9, _xfer+48(FP)
337 DO_ROUND( AX, BX, CX, R8, DX, R9, R10, R11, 48)
338 DO_ROUND(R11, AX, BX, CX, R8, DX, R9, R10, 52)
339 DO_ROUND(R10, R11, AX, BX, CX, R8, DX, R9, 56)
340 DO_ROUND( R9, R10, R11, AX, BX, CX, R8, DX, 60)
341
342 MOVOU X5, X9
343 LONG $0xfe0f4466; WORD $0x104d // PADDD XMM9, 16[RBP] /* Add 2nd constant to message */
344 MOVOU X9, _xfer+48(FP)
345 ADDQ $32, BP
346 DO_ROUND( DX, R9, R10, R11, AX, BX, CX, R8, 48)
347 DO_ROUND( R8, DX, R9, R10, R11, AX, BX, CX, 52)
348 DO_ROUND( CX, R8, DX, R9, R10, R11, AX, BX, 56)
349 DO_ROUND( BX, CX, R8, DX, R9, R10, R11, AX, 60)
350
351 MOVOU X6, X4
352 MOVOU X7, X5
353
354 SUBQ $1, DI
355 JNE loop2
356
357 MOVQ h+0(FP), SI // SI: &h
358 ADDL (0*4)(SI), AX // H0 = a + H0
359 MOVL AX, (0*4)(SI)
360 ADDL (1*4)(SI), BX // H1 = b + H1
361 MOVL BX, (1*4)(SI)
362 ADDL (2*4)(SI), CX // H2 = c + H2
363 MOVL CX, (2*4)(SI)
364 ADDL (3*4)(SI), R8 // H3 = d + H3
365 MOVL R8, (3*4)(SI)
366 ADDL (4*4)(SI), DX // H4 = e + H4
367 MOVL DX, (4*4)(SI)
368 ADDL (5*4)(SI), R9 // H5 = f + H5
369 MOVL R9, (5*4)(SI)
370 ADDL (6*4)(SI), R10 // H6 = g + H6
371 MOVL R10, (6*4)(SI)
372 ADDL (7*4)(SI), R11 // H7 = h + H7
373 MOVL R11, (7*4)(SI)
374
375 MOVQ _inp+72(FP), SI
376 ADDQ $64, SI
377 CMPQ _inp_end+64(FP), SI
378 JNE loop0
379
380 done_hash:
381 RET
382
383 // Constants table
384 DATA constants<>+0x0(SB)/8, $0x71374491428a2f98
385 DATA constants<>+0x8(SB)/8, $0xe9b5dba5b5c0fbcf
386 DATA constants<>+0x10(SB)/8, $0x59f111f13956c25b
387 DATA constants<>+0x18(SB)/8, $0xab1c5ed5923f82a4
388 DATA constants<>+0x20(SB)/8, $0x12835b01d807aa98
389 DATA constants<>+0x28(SB)/8, $0x550c7dc3243185be
390 DATA constants<>+0x30(SB)/8, $0x80deb1fe72be5d74
391 DATA constants<>+0x38(SB)/8, $0xc19bf1749bdc06a7
392 DATA constants<>+0x40(SB)/8, $0xefbe4786e49b69c1
393 DATA constants<>+0x48(SB)/8, $0x240ca1cc0fc19dc6
394 DATA constants<>+0x50(SB)/8, $0x4a7484aa2de92c6f
395 DATA constants<>+0x58(SB)/8, $0x76f988da5cb0a9dc
396 DATA constants<>+0x60(SB)/8, $0xa831c66d983e5152
397 DATA constants<>+0x68(SB)/8, $0xbf597fc7b00327c8
398 DATA constants<>+0x70(SB)/8, $0xd5a79147c6e00bf3
399 DATA constants<>+0x78(SB)/8, $0x1429296706ca6351
400 DATA constants<>+0x80(SB)/8, $0x2e1b213827b70a85
401 DATA constants<>+0x88(SB)/8, $0x53380d134d2c6dfc
402 DATA constants<>+0x90(SB)/8, $0x766a0abb650a7354
403 DATA constants<>+0x98(SB)/8, $0x92722c8581c2c92e
404 DATA constants<>+0xa0(SB)/8, $0xa81a664ba2bfe8a1
405 DATA constants<>+0xa8(SB)/8, $0xc76c51a3c24b8b70
406 DATA constants<>+0xb0(SB)/8, $0xd6990624d192e819
407 DATA constants<>+0xb8(SB)/8, $0x106aa070f40e3585
408 DATA constants<>+0xc0(SB)/8, $0x1e376c0819a4c116
409 DATA constants<>+0xc8(SB)/8, $0x34b0bcb52748774c
410 DATA constants<>+0xd0(SB)/8, $0x4ed8aa4a391c0cb3
411 DATA constants<>+0xd8(SB)/8, $0x682e6ff35b9cca4f
412 DATA constants<>+0xe0(SB)/8, $0x78a5636f748f82ee
413 DATA constants<>+0xe8(SB)/8, $0x8cc7020884c87814
414 DATA constants<>+0xf0(SB)/8, $0xa4506ceb90befffa
415 DATA constants<>+0xf8(SB)/8, $0xc67178f2bef9a3f7
416
417 DATA bflipMask<>+0x00(SB)/8, $0x0405060700010203
418 DATA bflipMask<>+0x08(SB)/8, $0x0c0d0e0f08090a0b
419
420 DATA shuf00BA<>+0x00(SB)/8, $0x0b0a090803020100
421 DATA shuf00BA<>+0x08(SB)/8, $0xFFFFFFFFFFFFFFFF
422
423 DATA shufDC00<>+0x00(SB)/8, $0xFFFFFFFFFFFFFFFF
424 DATA shufDC00<>+0x08(SB)/8, $0x0b0a090803020100
425
426 GLOBL constants<>(SB), 8, $256
427 GLOBL bflipMask<>(SB), (NOPTR+RODATA), $16
428 GLOBL shuf00BA<>(SB), (NOPTR+RODATA), $16
429 GLOBL shufDC00<>(SB), (NOPTR+RODATA), $16
0 //+build !noasm
1
2 /*
3 * Minio Cloud Storage, (C) 2016 Minio, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 package sha256
19
20 func blockArmGo(dig *digest, p []byte) {}
21 func blockAvx2Go(dig *digest, p []byte) {}
22 func blockAvxGo(dig *digest, p []byte) {}
23 func blockSsseGo(dig *digest, p []byte) {}
0 //+build !noasm
1
2 /*
3 * Minio Cloud Storage, (C) 2016 Minio, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 package sha256
19
20 func blockArmGo(dig *digest, p []byte) {}
21
22 func blockAvxGo(dig *digest, p []byte) {
23
24 h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
25
26 blockAvx(h[:], p[:], 0, 0, 0, 0)
27
28 dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]
29 }
30
31 func blockAvx2Go(dig *digest, p []byte) {
32
33 h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
34
35 blockAvx2(h[:], p[:])
36
37 dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]
38 }
39
40 func blockSsseGo(dig *digest, p []byte) {
41
42 h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
43
44 blockSsse(h[:], p[:], 0, 0, 0, 0)
45
46 dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]
47 }
0 //+build !noasm
1
2 /*
3 * Minio Cloud Storage, (C) 2016 Minio, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 package sha256
19
20 func blockAvx2Go(dig *digest, p []byte) {}
21 func blockAvxGo(dig *digest, p []byte) {}
22 func blockSsseGo(dig *digest, p []byte) {}
23 func blockArmGo(dig *digest, p []byte) {}
0 //+build !noasm
1
2 /*
3 * Minio Cloud Storage, (C) 2016 Minio, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 package sha256
19
20 func blockAvx2Go(dig *digest, p []byte) {}
21 func blockAvxGo(dig *digest, p []byte) {}
22 func blockSsseGo(dig *digest, p []byte) {}
23
24 //go:noescape
25 func blockArm(h []uint32, message []uint8)
26
27 func blockArmGo(dig *digest, p []byte) {
28
29 h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
30
31 blockArm(h[:], p[:])
32
33 dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4],
34 h[5], h[6], h[7]
35 }
0 //+build !noasm !appengine
1
2 // ARM64 version of SHA256
3
4 //
5 // Minio Cloud Storage, (C) 2016 Minio, Inc.
6 //
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
10 //
11 // http://www.apache.org/licenses/LICENSE-2.0
12 //
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
18 //
19
20 //
21 // Based on implementaion as found in https://github.com/jocover/sha256-armv8
22 //
23 // Use github.com/minio/asm2plan9s on this file to assemble ARM instructions to
24 // their Plan9 equivalents
25 //
26
27 TEXT ·blockArm(SB), 7, $0
28 MOVD h+0(FP), R0
29 MOVD message+24(FP), R1
30 MOVD lenmessage+32(FP), R2 // length of message
31 SUBS $64, R2
32 BMI complete
33
34 // Load constants table pointer
35 MOVD $·constants(SB), R3
36
37 // Cache constants table in registers v16 - v31
38 WORD $0x4cdf2870 // ld1 {v16.4s-v19.4s}, [x3], #64
39 WORD $0x4cdf7800 // ld1 {v0.4s}, [x0], #16
40 WORD $0x4cdf2874 // ld1 {v20.4s-v23.4s}, [x3], #64
41
42 WORD $0x4c407801 // ld1 {v1.4s}, [x0]
43 WORD $0x4cdf2878 // ld1 {v24.4s-v27.4s}, [x3], #64
44 WORD $0xd1004000 // sub x0, x0, #0x10
45 WORD $0x4cdf287c // ld1 {v28.4s-v31.4s}, [x3], #64
46
47 loop:
48 // Main loop
49 WORD $0x4cdf2025 // ld1 {v5.16b-v8.16b}, [x1], #64
50 WORD $0x4ea01c02 // mov v2.16b, v0.16b
51 WORD $0x4ea11c23 // mov v3.16b, v1.16b
52 WORD $0x6e2008a5 // rev32 v5.16b, v5.16b
53 WORD $0x6e2008c6 // rev32 v6.16b, v6.16b
54 WORD $0x4eb084a9 // add v9.4s, v5.4s, v16.4s
55 WORD $0x6e2008e7 // rev32 v7.16b, v7.16b
56 WORD $0x4eb184ca // add v10.4s, v6.4s, v17.4s
57 WORD $0x4ea21c44 // mov v4.16b, v2.16b
58 WORD $0x5e094062 // sha256h q2, q3, v9.4s
59 WORD $0x5e095083 // sha256h2 q3, q4, v9.4s
60 WORD $0x5e2828c5 // sha256su0 v5.4s, v6.4s
61 WORD $0x6e200908 // rev32 v8.16b, v8.16b
62 WORD $0x4eb284e9 // add v9.4s, v7.4s, v18.4s
63 WORD $0x4ea21c44 // mov v4.16b, v2.16b
64 WORD $0x5e0a4062 // sha256h q2, q3, v10.4s
65 WORD $0x5e0a5083 // sha256h2 q3, q4, v10.4s
66 WORD $0x5e2828e6 // sha256su0 v6.4s, v7.4s
67 WORD $0x5e0860e5 // sha256su1 v5.4s, v7.4s, v8.4s
68 WORD $0x4eb3850a // add v10.4s, v8.4s, v19.4s
69 WORD $0x4ea21c44 // mov v4.16b, v2.16b
70 WORD $0x5e094062 // sha256h q2, q3, v9.4s
71 WORD $0x5e095083 // sha256h2 q3, q4, v9.4s
72 WORD $0x5e282907 // sha256su0 v7.4s, v8.4s
73 WORD $0x5e056106 // sha256su1 v6.4s, v8.4s, v5.4s
74 WORD $0x4eb484a9 // add v9.4s, v5.4s, v20.4s
75 WORD $0x4ea21c44 // mov v4.16b, v2.16b
76 WORD $0x5e0a4062 // sha256h q2, q3, v10.4s
77 WORD $0x5e0a5083 // sha256h2 q3, q4, v10.4s
78 WORD $0x5e2828a8 // sha256su0 v8.4s, v5.4s
79 WORD $0x5e0660a7 // sha256su1 v7.4s, v5.4s, v6.4s
80 WORD $0x4eb584ca // add v10.4s, v6.4s, v21.4s
81 WORD $0x4ea21c44 // mov v4.16b, v2.16b
82 WORD $0x5e094062 // sha256h q2, q3, v9.4s
83 WORD $0x5e095083 // sha256h2 q3, q4, v9.4s
84 WORD $0x5e2828c5 // sha256su0 v5.4s, v6.4s
85 WORD $0x5e0760c8 // sha256su1 v8.4s, v6.4s, v7.4s
86 WORD $0x4eb684e9 // add v9.4s, v7.4s, v22.4s
87 WORD $0x4ea21c44 // mov v4.16b, v2.16b
88 WORD $0x5e0a4062 // sha256h q2, q3, v10.4s
89 WORD $0x5e0a5083 // sha256h2 q3, q4, v10.4s
90 WORD $0x5e2828e6 // sha256su0 v6.4s, v7.4s
91 WORD $0x5e0860e5 // sha256su1 v5.4s, v7.4s, v8.4s
92 WORD $0x4eb7850a // add v10.4s, v8.4s, v23.4s
93 WORD $0x4ea21c44 // mov v4.16b, v2.16b
94 WORD $0x5e094062 // sha256h q2, q3, v9.4s
95 WORD $0x5e095083 // sha256h2 q3, q4, v9.4s
96 WORD $0x5e282907 // sha256su0 v7.4s, v8.4s
97 WORD $0x5e056106 // sha256su1 v6.4s, v8.4s, v5.4s
98 WORD $0x4eb884a9 // add v9.4s, v5.4s, v24.4s
99 WORD $0x4ea21c44 // mov v4.16b, v2.16b
100 WORD $0x5e0a4062 // sha256h q2, q3, v10.4s
101 WORD $0x5e0a5083 // sha256h2 q3, q4, v10.4s
102 WORD $0x5e2828a8 // sha256su0 v8.4s, v5.4s
103 WORD $0x5e0660a7 // sha256su1 v7.4s, v5.4s, v6.4s
104 WORD $0x4eb984ca // add v10.4s, v6.4s, v25.4s
105 WORD $0x4ea21c44 // mov v4.16b, v2.16b
106 WORD $0x5e094062 // sha256h q2, q3, v9.4s
107 WORD $0x5e095083 // sha256h2 q3, q4, v9.4s
108 WORD $0x5e2828c5 // sha256su0 v5.4s, v6.4s
109 WORD $0x5e0760c8 // sha256su1 v8.4s, v6.4s, v7.4s
110 WORD $0x4eba84e9 // add v9.4s, v7.4s, v26.4s
111 WORD $0x4ea21c44 // mov v4.16b, v2.16b
112 WORD $0x5e0a4062 // sha256h q2, q3, v10.4s
113 WORD $0x5e0a5083 // sha256h2 q3, q4, v10.4s
114 WORD $0x5e2828e6 // sha256su0 v6.4s, v7.4s
115 WORD $0x5e0860e5 // sha256su1 v5.4s, v7.4s, v8.4s
116 WORD $0x4ebb850a // add v10.4s, v8.4s, v27.4s
117 WORD $0x4ea21c44 // mov v4.16b, v2.16b
118 WORD $0x5e094062 // sha256h q2, q3, v9.4s
119 WORD $0x5e095083 // sha256h2 q3, q4, v9.4s
120 WORD $0x5e282907 // sha256su0 v7.4s, v8.4s
121 WORD $0x5e056106 // sha256su1 v6.4s, v8.4s, v5.4s
122 WORD $0x4ebc84a9 // add v9.4s, v5.4s, v28.4s
123 WORD $0x4ea21c44 // mov v4.16b, v2.16b
124 WORD $0x5e0a4062 // sha256h q2, q3, v10.4s
125 WORD $0x5e0a5083 // sha256h2 q3, q4, v10.4s
126 WORD $0x5e2828a8 // sha256su0 v8.4s, v5.4s
127 WORD $0x5e0660a7 // sha256su1 v7.4s, v5.4s, v6.4s
128 WORD $0x4ebd84ca // add v10.4s, v6.4s, v29.4s
129 WORD $0x4ea21c44 // mov v4.16b, v2.16b
130 WORD $0x5e094062 // sha256h q2, q3, v9.4s
131 WORD $0x5e095083 // sha256h2 q3, q4, v9.4s
132 WORD $0x5e0760c8 // sha256su1 v8.4s, v6.4s, v7.4s
133 WORD $0x4ebe84e9 // add v9.4s, v7.4s, v30.4s
134 WORD $0x4ea21c44 // mov v4.16b, v2.16b
135 WORD $0x5e0a4062 // sha256h q2, q3, v10.4s
136 WORD $0x5e0a5083 // sha256h2 q3, q4, v10.4s
137 WORD $0x4ebf850a // add v10.4s, v8.4s, v31.4s
138 WORD $0x4ea21c44 // mov v4.16b, v2.16b
139 WORD $0x5e094062 // sha256h q2, q3, v9.4s
140 WORD $0x5e095083 // sha256h2 q3, q4, v9.4s
141 WORD $0x4ea21c44 // mov v4.16b, v2.16b
142 WORD $0x5e0a4062 // sha256h q2, q3, v10.4s
143 WORD $0x5e0a5083 // sha256h2 q3, q4, v10.4s
144 WORD $0x4ea38421 // add v1.4s, v1.4s, v3.4s
145 WORD $0x4ea28400 // add v0.4s, v0.4s, v2.4s
146
147 SUBS $64, R2
148 BPL loop
149
150 // Store result
151 WORD $0x4c00a800 // st1 {v0.4s, v1.4s}, [x0]
152
153 complete:
154 RET
155
156
157 // Constants table
158 DATA ·constants+0x0(SB)/8, $0x71374491428a2f98
159 DATA ·constants+0x8(SB)/8, $0xe9b5dba5b5c0fbcf
160 DATA ·constants+0x10(SB)/8, $0x59f111f13956c25b
161 DATA ·constants+0x18(SB)/8, $0xab1c5ed5923f82a4
162 DATA ·constants+0x20(SB)/8, $0x12835b01d807aa98
163 DATA ·constants+0x28(SB)/8, $0x550c7dc3243185be
164 DATA ·constants+0x30(SB)/8, $0x80deb1fe72be5d74
165 DATA ·constants+0x38(SB)/8, $0xc19bf1749bdc06a7
166 DATA ·constants+0x40(SB)/8, $0xefbe4786e49b69c1
167 DATA ·constants+0x48(SB)/8, $0x240ca1cc0fc19dc6
168 DATA ·constants+0x50(SB)/8, $0x4a7484aa2de92c6f
169 DATA ·constants+0x58(SB)/8, $0x76f988da5cb0a9dc
170 DATA ·constants+0x60(SB)/8, $0xa831c66d983e5152
171 DATA ·constants+0x68(SB)/8, $0xbf597fc7b00327c8
172 DATA ·constants+0x70(SB)/8, $0xd5a79147c6e00bf3
173 DATA ·constants+0x78(SB)/8, $0x1429296706ca6351
174 DATA ·constants+0x80(SB)/8, $0x2e1b213827b70a85
175 DATA ·constants+0x88(SB)/8, $0x53380d134d2c6dfc
176 DATA ·constants+0x90(SB)/8, $0x766a0abb650a7354
177 DATA ·constants+0x98(SB)/8, $0x92722c8581c2c92e
178 DATA ·constants+0xa0(SB)/8, $0xa81a664ba2bfe8a1
179 DATA ·constants+0xa8(SB)/8, $0xc76c51a3c24b8b70
180 DATA ·constants+0xb0(SB)/8, $0xd6990624d192e819
181 DATA ·constants+0xb8(SB)/8, $0x106aa070f40e3585
182 DATA ·constants+0xc0(SB)/8, $0x1e376c0819a4c116
183 DATA ·constants+0xc8(SB)/8, $0x34b0bcb52748774c
184 DATA ·constants+0xd0(SB)/8, $0x4ed8aa4a391c0cb3
185 DATA ·constants+0xd8(SB)/8, $0x682e6ff35b9cca4f
186 DATA ·constants+0xe0(SB)/8, $0x78a5636f748f82ee
187 DATA ·constants+0xe8(SB)/8, $0x8cc7020884c87814
188 DATA ·constants+0xf0(SB)/8, $0xa4506ceb90befffa
189 DATA ·constants+0xf8(SB)/8, $0xc67178f2bef9a3f7
190
191 GLOBL ·constants(SB), 8, $256
192
0 //+build !arm64 !amd64 noasm appengine
1
2 /*
3 * Minio Cloud Storage, (C) 2016 Minio, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 package sha256
19
20 func blockGeneric(dig *digest, p []byte) {
21 var w [64]uint32
22 h0, h1, h2, h3, h4, h5, h6, h7 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]
23 for len(p) >= chunk {
24 // Can interlace the computation of w with the
25 // rounds below if needed for speed.
26 for i := 0; i < 16; i++ {
27 j := i * 4
28 w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3])
29 }
30 for i := 16; i < 64; i++ {
31 v1 := w[i-2]
32 t1 := (v1>>17 | v1<<(32-17)) ^ (v1>>19 | v1<<(32-19)) ^ (v1 >> 10)
33 v2 := w[i-15]
34 t2 := (v2>>7 | v2<<(32-7)) ^ (v2>>18 | v2<<(32-18)) ^ (v2 >> 3)
35 w[i] = t1 + w[i-7] + t2 + w[i-16]
36 }
37
38 a, b, c, d, e, f, g, h := h0, h1, h2, h3, h4, h5, h6, h7
39
40 for i := 0; i < 64; i++ {
41 t1 := h + ((e>>6 | e<<(32-6)) ^ (e>>11 | e<<(32-11)) ^ (e>>25 | e<<(32-25))) + ((e & f) ^ (^e & g)) + _K[i] + w[i]
42
43 t2 := ((a>>2 | a<<(32-2)) ^ (a>>13 | a<<(32-13)) ^ (a>>22 | a<<(32-22))) + ((a & b) ^ (a & c) ^ (b & c))
44
45 h = g
46 g = f
47 f = e
48 e = d + t1
49 d = c
50 c = b
51 b = a
52 a = t1 + t2
53 }
54
55 h0 += a
56 h1 += b
57 h2 += c
58 h3 += d
59 h4 += e
60 h5 += f
61 h6 += g
62 h7 += h
63
64 p = p[chunk:]
65 }
66
67 dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h0, h1, h2, h3, h4, h5, h6, h7
68 }
69
70 var _K = []uint32{
71 0x428a2f98,
72 0x71374491,
73 0xb5c0fbcf,
74 0xe9b5dba5,
75 0x3956c25b,
76 0x59f111f1,
77 0x923f82a4,
78 0xab1c5ed5,
79 0xd807aa98,
80 0x12835b01,
81 0x243185be,
82 0x550c7dc3,
83 0x72be5d74,
84 0x80deb1fe,
85 0x9bdc06a7,
86 0xc19bf174,
87 0xe49b69c1,
88 0xefbe4786,
89 0x0fc19dc6,
90 0x240ca1cc,
91 0x2de92c6f,
92 0x4a7484aa,
93 0x5cb0a9dc,
94 0x76f988da,
95 0x983e5152,
96 0xa831c66d,
97 0xb00327c8,
98 0xbf597fc7,
99 0xc6e00bf3,
100 0xd5a79147,
101 0x06ca6351,
102 0x14292967,
103 0x27b70a85,
104 0x2e1b2138,
105 0x4d2c6dfc,
106 0x53380d13,
107 0x650a7354,
108 0x766a0abb,
109 0x81c2c92e,
110 0x92722c85,
111 0xa2bfe8a1,
112 0xa81a664b,
113 0xc24b8b70,
114 0xc76c51a3,
115 0xd192e819,
116 0xd6990624,
117 0xf40e3585,
118 0x106aa070,
119 0x19a4c116,
120 0x1e376c08,
121 0x2748774c,
122 0x34b0bcb5,
123 0x391c0cb3,
124 0x4ed8aa4a,
125 0x5b9cca4f,
126 0x682e6ff3,
127 0x748f82ee,
128 0x78a5636f,
129 0x84c87814,
130 0x8cc70208,
131 0x90befffa,
132 0xa4506ceb,
133 0xbef9a3f7,
134 0xc67178f2,
135 }
0 /*
1 * Minio Cloud Storage, (C) 2016 Minio, Inc.
2 *
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 package sha256
17
18 func blockAvx2Go(dig *digest, p []byte) {}
19 func blockAvxGo(dig *digest, p []byte) {}
20 func blockSsseGo(dig *digest, p []byte) {}
21 func blockArmGo(dig *digest, p []byte) {}
0 /*
1 * Minio Cloud Storage, (C) 2016 Minio, Inc.
2 *
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 package sha256
17
18 func blockAvx2Go(dig *digest, p []byte) {}
19 func blockAvxGo(dig *digest, p []byte) {}
20 func blockSsseGo(dig *digest, p []byte) {}
21 func blockArmGo(dig *digest, p []byte) {}