Codebase list golang-github-minio-sha256-simd / upstream/0.0_git20161015.0.f78567f
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
+21
-0
.travis.yml less more
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 ./...
+202
-0
LICENSE less more
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.
+153
-0
README.md less more
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.
+32
-0
appveyor.yml less more
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
+55
-0
cpuid.go less more
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 }
+24
-0
cpuid_386.go less more
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 }
+53
-0
cpuid_386.s less more
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
+24
-0
cpuid_amd64.go less more
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 }
+54
-0
cpuid_amd64.s less more
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
+33
-0
cpuid_arm.go less more
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 }
+33
-0
cpuid_arm64.go less more
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 }
+32
-0
cpuid_ppc64.go less more
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 }
+32
-0
cpuid_ppc64le.go less more
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 }
+176
-0
sha256.go less more
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 }
+1172
-0
sha256_test.go less more
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 }
+22
-0
sha256blockAvx2_amd64.go less more
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)
+1442
-0
sha256blockAvx2_amd64.s less more
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