fix(*): Vendored project dependencies

2024-04-08 14:00:37 +12:00
parent fa40e6ee71
commit ff1798b10b
1601 changed files with 485259 additions and 1 deletions
--- a/vendor/github.com/pjbgf/sha1cd/Dockerfile.arm
+++ b/vendor/github.com/pjbgf/sha1cd/Dockerfile.arm
@@ -0,0 +1,23 @@
+FROM golang:1.19@sha256:dc76ef03e54c34a00dcdca81e55c242d24b34d231637776c4bb5c1a8e8514253
+
+ENV GOOS=linux
+ENV GOARCH=arm
+ENV CGO_ENABLED=1
+ENV CC=arm-linux-gnueabihf-gcc
+ENV PATH="/go/bin/${GOOS}_${GOARCH}:${PATH}"
+ENV PKG_CONFIG_PATH=/usr/lib/arm-linux-gnueabihf/pkgconfig
+
+RUN dpkg --add-architecture armhf \
+    && apt update \
+    && apt install -y --no-install-recommends \
+        upx \
+        gcc-arm-linux-gnueabihf \
+        libc6-dev-armhf-cross \
+        pkg-config \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY . /src/workdir
+
+WORKDIR /src/workdir
+
+RUN go build ./...
--- a/vendor/github.com/pjbgf/sha1cd/Dockerfile.arm64
+++ b/vendor/github.com/pjbgf/sha1cd/Dockerfile.arm64
@@ -0,0 +1,23 @@
+FROM golang:1.19@sha256:dc76ef03e54c34a00dcdca81e55c242d24b34d231637776c4bb5c1a8e8514253
+
+ENV GOOS=linux
+ENV GOARCH=arm64
+ENV CGO_ENABLED=1
+ENV CC=aarch64-linux-gnu-gcc
+ENV PATH="/go/bin/${GOOS}_${GOARCH}:${PATH}"
+ENV PKG_CONFIG_PATH=/usr/lib/aarch64-linux-gnu/pkgconfig
+
+# install build & runtime dependencies
+RUN dpkg --add-architecture arm64 \
+    && apt update \
+    && apt install -y --no-install-recommends \
+        gcc-aarch64-linux-gnu \
+        libc6-dev-arm64-cross \
+        pkg-config \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY . /src/workdir
+
+WORKDIR /src/workdir
+
+RUN go build ./...
--- a/vendor/github.com/pjbgf/sha1cd/Makefile
+++ b/vendor/github.com/pjbgf/sha1cd/Makefile
@@ -0,0 +1,32 @@
+FUZZ_TIME ?= 1m
+
+export CGO_ENABLED := 1
+
+.PHONY: test
+test:
+	go test ./...
+
+.PHONY: bench
+bench:
+	go test -benchmem -run=^$$ -bench ^Benchmark ./...
+
+.PHONY: fuzz
+fuzz:
+	go test -tags gofuzz -fuzz=. -fuzztime=$(FUZZ_TIME) ./test/
+
+# Cross build project in arm/v7.
+build-arm:
+	docker build -t sha1cd-arm -f Dockerfile.arm .
+	docker run --rm sha1cd-arm
+
+# Cross build project in arm64.
+build-arm64:
+	docker build -t sha1cd-arm64 -f Dockerfile.arm64 .
+	docker run --rm sha1cd-arm64
+
+# Build with cgo disabled.
+build-nocgo:
+	CGO_ENABLED=0 go build ./cgo
+
+# Run cross-compilation to assure supported architectures.
+cross-build: build-arm build-arm64 build-nocgo
--- a/vendor/github.com/pjbgf/sha1cd/README.md
+++ b/vendor/github.com/pjbgf/sha1cd/README.md
@@ -0,0 +1,58 @@
+# sha1cd
+
+A Go implementation of SHA1 with counter-cryptanalysis, which detects
+collision attacks. 
+
+The `cgo/lib` code is a carbon copy of the [original code], based on
+the award winning [white paper] by Marc Stevens.
+
+The Go implementation is largely based off Go's generic sha1.
+At present no SIMD optimisations have been implemented.
+
+## Usage
+
+`sha1cd` can be used as a drop-in replacement for `crypto/sha1`:
+
+```golang
+import "github.com/pjbgf/sha1cd"
+
+func test(){
+	data := []byte("data to be sha1 hashed")
+	h := sha1cd.Sum(data)
+	fmt.Printf("hash: %q\n", hex.EncodeToString(h))
+}
+```
+
+To obtain information as to whether a collision was found, use the
+func `CollisionResistantSum`.
+
+```golang
+import "github.com/pjbgf/sha1cd"
+
+func test(){
+	data := []byte("data to be sha1 hashed")
+	h, col  := sha1cd.CollisionResistantSum(data)
+	if col {
+		fmt.Println("collision found!")
+	}
+	fmt.Printf("hash: %q", hex.EncodeToString(h))
+}
+```
+
+Note that the algorithm will automatically avoid collision, by 
+extending the SHA1 to 240-steps, instead of 80 when a collision
+attempt is detected. Therefore, inputs that contains the unavoidable
+bit conditions will yield a different hash from `sha1cd`, when compared
+with results using `crypto/sha1`. Valid inputs will have matching the outputs.
+
+## References
+- https://shattered.io/
+- https://github.com/cr-marcstevens/sha1collisiondetection
+- https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
+
+## Use of the Original Implementation
+- https://github.com/git/git/commit/28dc98e343ca4eb370a29ceec4c19beac9b5c01e
+- https://github.com/libgit2/libgit2/pull/4136
+
+[original code]: https://github.com/cr-marcstevens/sha1collisiondetection
+[white paper]: https://marc-stevens.nl/research/papers/C13-S.pdf
--- a/vendor/github.com/pjbgf/sha1cd/cgo/README.md
+++ b/vendor/github.com/pjbgf/sha1cd/cgo/README.md
@@ -0,0 +1,102 @@
+# sha1collisiondetection
+Library and command line tool to detect SHA-1 collisions in files
+
+Copyright 2017 Marc Stevens <marc@marc-stevens.nl>
+
+Distributed under the MIT Software License.
+
+See accompanying file LICENSE.txt or copy at https://opensource.org/licenses/MIT.
+
+## Developers
+
+- Marc Stevens, CWI Amsterdam (https://marc-stevens.nl)
+- Dan Shumow, Microsoft Research (https://www.microsoft.com/en-us/research/people/danshu/)
+
+## About
+This library and command line tool were designed as near drop-in replacements for common SHA-1 libraries and sha1sum.
+They will compute the SHA-1 hash of any given file and additionally will detect cryptanalytic collision attacks against SHA-1 present in each file. It is very fast and takes less than twice the amount of time as regular SHA-1.
+
+More specifically they will detect any cryptanalytic collision attack against SHA-1 using any of the top 32 SHA-1 disturbance vectors with probability 1:
+```
+    I(43,0), I(44,0), I(45,0), I(46,0), I(47,0), I(48,0), I(49,0), I(50,0), I(51,0), I(52,0),
+    I(46,2), I(47,2), I(48,2), I(49,2), I(50,2), I(51,2),
+    II(45,0), II(46,0), II(47,0), II(48,0), II(49,0), II(50,0), II(51,0), II(52,0), II(53,0), II(54,0), II(55,0), II(56,0),
+    II(46,2), II(49,2), II(50,2), II(51,2)
+```
+The possibility of false positives can be neglected as the probability is smaller than 2^-90.
+
+The library supports both an indicator flag that applications can check and act on, as well as a special _safe-hash_ mode that returns the real SHA-1 hash when no collision was detected and a different _safe_ hash when a collision was detected.
+Colliding files will have the same SHA-1 hash, but will have different unpredictable safe-hashes.
+This essentially enables protection of applications against SHA-1 collisions with no further changes in the application, e.g., digital signature forgeries based on SHA-1 collisions automatically become invalid.
+
+For the theoretical explanation of collision detection see the award-winning paper on _Counter-Cryptanalysis_:
+
+Counter-cryptanalysis, Marc Stevens, CRYPTO 2013, Lecture Notes in Computer Science, vol. 8042, Springer, 2013, pp. 129-146,
+https://marc-stevens.nl/research/papers/C13-S.pdf
+
+
+## Inclusion in other programs
+
+In order to make it easier to include these sources in other project
+there are several preprocessor macros that the code uses. Rather than
+copy/pasting and customizing or specializing the code, first see if
+setting any of these defines appropriately will allow you to avoid
+modifying the code yourself.
+
+- SHA1DC_NO_STANDARD_INCLUDES
+
+ Skips including standard headers. Use this if your project for
+ whatever reason wishes to do its own header includes.
+
+- SHA1DC_CUSTOM_INCLUDE_SHA1_C
+
+  Includes a custom header at the top of sha1.c. Usually this would be
+  set in conjunction with SHA1DC_NO_STANDARD_INCLUDES to point to a
+  header file which includes various standard headers.
+
+- SHA1DC_INIT_SAFE_HASH_DEFAULT
+
+  Sets the default for safe_hash in SHA1DCInit(). Valid values are 0
+  and 1. If unset 1 is the default.
+
+- SHA1DC_CUSTOM_TRAILING_INCLUDE_SHA1_C
+
+  Includes a custom trailer in sha1.c. Useful for any extra utility
+  functions that make use of the functions already defined in sha1.c.
+
+- SHA1DC_CUSTOM_TRAILING_INCLUDE_SHA1_H
+
+  Includes a custom trailer in sha1.h. Useful for defining the
+  prototypes of the functions or code included by
+  SHA1DC_CUSTOM_TRAILING_INCLUDE_SHA1_C.
+
+- SHA1DC_CUSTOM_INCLUDE_UBC_CHECK_C
+
+  Includes a custom header at the top of ubc_check.c.
+
+- SHA1DC_CUSTOM_TRAILING_INCLUDE_UBC_CHECK_C
+
+  Includes a custom trailer in ubc_check.c.
+
+- SHA1DC_CUSTOM_TRAILING_INCLUDE_UBC_CHECK_H
+
+  Includes a custom trailer in ubc_check.H.
+
+This code will try to auto-detect certain things based on
+CPU/platform. Unless you're running on some really obscure CPU or
+porting to a new platform you should not need to tweak this. If you do
+please open an issue at
+https://github.com/cr-marcstevens/sha1collisiondetection
+
+- SHA1DC_FORCE_LITTLEENDIAN / SHA1DC_FORCE_BIGENDIAN
+
+  Override the check for processor endianenss and force either
+  Little-Endian or Big-Endian.
+
+- SHA1DC_FORCE_UNALIGNED_ACCESS
+
+  Permit unaligned access. This will fail on e.g. SPARC processors, so
+  it's only permitted on a whitelist of processors. If your CPU isn't
+  detected as allowing this, and allows unaligned access, setting this
+  may improve performance (or make it worse, if the kernel has to
+  catch and emulate such access on its own).
--- a/vendor/github.com/pjbgf/sha1cd/cgo/fallback_no_cgo.go
+++ b/vendor/github.com/pjbgf/sha1cd/cgo/fallback_no_cgo.go
@@ -0,0 +1,32 @@
+//go:build !cgo
+// +build !cgo
+
+package cgo
+
+import (
+	"hash"
+
+	"github.com/pjbgf/sha1cd"
+	"github.com/pjbgf/sha1cd/ubc"
+)
+
+// CalculateDvMask falls back to github.com/pjbgf/sha1cd/ubc implementation
+// due to CGO being disabled at compilation time.
+func CalculateDvMask(W []uint32) (uint32, error) {
+	return ubc.CalculateDvMask(W)
+}
+
+// CalculateDvMask falls back to github.com/pjbgf/sha1cd implementation
+// due to CGO being disabled at compilation time.
+func New() hash.Hash {
+	return sha1cd.New()
+}
+
+// CalculateDvMask falls back to github.com/pjbgf/sha1cd implementation
+// due to CGO being disabled at compilation time.
+func Sum(data []byte) ([]byte, bool) {
+	d := sha1cd.New().(sha1cd.CollisionResistantHash)
+	d.Write(data)
+
+	return d.CollisionResistantSum(nil)
+}
--- a/vendor/github.com/pjbgf/sha1cd/cgo/sha1.c
+++ b/vendor/github.com/pjbgf/sha1cd/cgo/sha1.c
--- a/vendor/github.com/pjbgf/sha1cd/cgo/sha1.go
+++ b/vendor/github.com/pjbgf/sha1cd/cgo/sha1.go
@@ -0,0 +1,78 @@
+package cgo
+
+// #include <sha1.h>
+// #include <ubc_check.h>
+import "C"
+
+import (
+	"crypto"
+	"hash"
+	"unsafe"
+)
+
+const (
+	Size      = 20
+	BlockSize = 64
+)
+
+func init() {
+	crypto.RegisterHash(crypto.SHA1, New)
+}
+
+func New() hash.Hash {
+	d := new(digest)
+	d.Reset()
+	return d
+}
+
+type digest struct {
+	ctx C.SHA1_CTX
+}
+
+func (d *digest) sum() ([]byte, bool) {
+	b := make([]byte, Size)
+	c := C.SHA1DCFinal((*C.uchar)(unsafe.Pointer(&b[0])), &d.ctx)
+	if c != 0 {
+		return b, true
+	}
+
+	return b, false
+}
+
+func (d *digest) Sum(in []byte) []byte {
+	d0 := *d // use a copy of d to avoid race conditions.
+	h, _ := d0.sum()
+	return append(in, h...)
+}
+
+func (d *digest) CollisionResistantSum(in []byte) ([]byte, bool) {
+	d0 := *d // use a copy of d to avoid race conditions.
+	h, c := d0.sum()
+	return append(in, h...), c
+}
+
+func (d *digest) Reset() {
+	C.SHA1DCInit(&d.ctx)
+}
+
+func (d *digest) Size() int { return Size }
+
+func (d *digest) BlockSize() int { return BlockSize }
+
+func Sum(data []byte) ([]byte, bool) {
+	d := New().(*digest)
+	d.Write(data)
+
+	return d.sum()
+}
+
+func (d *digest) Write(p []byte) (nn int, err error) {
+	if len(p) == 0 {
+		return 0, nil
+	}
+
+	data := (*C.char)(unsafe.Pointer(&p[0]))
+	C.SHA1DCUpdate(&d.ctx, data, (C.size_t)(len(p)))
+
+	return len(p), nil
+}
--- a/vendor/github.com/pjbgf/sha1cd/cgo/sha1.h
+++ b/vendor/github.com/pjbgf/sha1cd/cgo/sha1.h
@@ -0,0 +1,114 @@
+/***
+ * Copyright 2017 Marc Stevens <marc@marc-stevens.nl>, Dan Shumow <danshu@microsoft.com>
+ * Distributed under the MIT Software License.
+ * See accompanying file LICENSE.txt or copy at
+ * https://opensource.org/licenses/MIT
+ ***/
+
+// Originally from: https://github.com/cr-marcstevens/sha1collisiondetection
+
+#ifndef SHA1DC_SHA1_H
+#define SHA1DC_SHA1_H
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+
+#ifndef SHA1DC_NO_STANDARD_INCLUDES
+#include <stdint.h>
+#endif
+
+	/* sha-1 compression function that takes an already expanded message, and additionally store intermediate states */
+	/* only stores states ii (the state between step ii-1 and step ii) when DOSTORESTATEii is defined in ubc_check.h */
+	void sha1_compression_states(uint32_t[5], const uint32_t[16], uint32_t[80], uint32_t[80][5]);
+
+	/*
+	// Function type for sha1_recompression_step_T (uint32_t ihvin[5], uint32_t ihvout[5], const uint32_t me2[80], const uint32_t state[5]).
+	// Where 0 <= T < 80
+	//       me2 is an expanded message (the expansion of an original message block XOR'ed with a disturbance vector's message block difference.)
+	//       state is the internal state (a,b,c,d,e) before step T of the SHA-1 compression function while processing the original message block.
+	// The function will return:
+	//       ihvin: The reconstructed input chaining value.
+	//       ihvout: The reconstructed output chaining value.
+	*/
+	typedef void (*sha1_recompression_type)(uint32_t *, uint32_t *, const uint32_t *, const uint32_t *);
+
+	/* A callback function type that can be set to be called when a collision block has been found: */
+	/* void collision_block_callback(uint64_t byteoffset, const uint32_t ihvin1[5], const uint32_t ihvin2[5], const uint32_t m1[80], const uint32_t m2[80]) */
+	typedef void (*collision_block_callback)(uint64_t, const uint32_t *, const uint32_t *, const uint32_t *, const uint32_t *);
+
+	/* The SHA-1 context. */
+	typedef struct
+	{
+		uint64_t total;
+		uint32_t ihv[5];
+		unsigned char buffer[64];
+		int found_collision;
+		int safe_hash;
+		int detect_coll;
+		int ubc_check;
+		int reduced_round_coll;
+		collision_block_callback callback;
+
+		uint32_t ihv1[5];
+		uint32_t ihv2[5];
+		uint32_t m1[80];
+		uint32_t m2[80];
+		uint32_t states[80][5];
+	} SHA1_CTX;
+
+	/* Initialize SHA-1 context. */
+	void SHA1DCInit(SHA1_CTX *);
+
+	/*
+		Function to enable safe SHA-1 hashing:
+		Collision attacks are thwarted by hashing a detected near-collision block 3 times.
+		Think of it as extending SHA-1 from 80-steps to 240-steps for such blocks:
+			The best collision attacks against SHA-1 have complexity about 2^60,
+			thus for 240-steps an immediate lower-bound for the best cryptanalytic attacks would be 2^180.
+			An attacker would be better off using a generic birthday search of complexity 2^80.
+
+	   Enabling safe SHA-1 hashing will result in the correct SHA-1 hash for messages where no collision attack was detected,
+	   but it will result in a different SHA-1 hash for messages where a collision attack was detected.
+	   This will automatically invalidate SHA-1 based digital signature forgeries.
+	   Enabled by default.
+	*/
+	void SHA1DCSetSafeHash(SHA1_CTX *, int);
+
+	/*
+		Function to disable or enable the use of Unavoidable Bitconditions (provides a significant speed up).
+		Enabled by default
+	 */
+	void SHA1DCSetUseUBC(SHA1_CTX *, int);
+
+	/*
+		Function to disable or enable the use of Collision Detection.
+		Enabled by default.
+	 */
+	void SHA1DCSetUseDetectColl(SHA1_CTX *, int);
+
+	/* function to disable or enable the detection of reduced-round SHA-1 collisions */
+	/* disabled by default */
+	void SHA1DCSetDetectReducedRoundCollision(SHA1_CTX *, int);
+
+	/* function to set a callback function, pass NULL to disable */
+	/* by default no callback set */
+	void SHA1DCSetCallback(SHA1_CTX *, collision_block_callback);
+
+	/* update SHA-1 context with buffer contents */
+	void SHA1DCUpdate(SHA1_CTX *, const char *, size_t);
+
+	/* obtain SHA-1 hash from SHA-1 context */
+	/* returns: 0 = no collision detected, otherwise = collision found => warn user for active attack */
+	int SHA1DCFinal(unsigned char[20], SHA1_CTX *);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#ifdef SHA1DC_CUSTOM_TRAILING_INCLUDE_SHA1_H
+#include SHA1DC_CUSTOM_TRAILING_INCLUDE_SHA1_H
+#endif
+
+#endif
--- a/vendor/github.com/pjbgf/sha1cd/cgo/ubc_check.c
+++ b/vendor/github.com/pjbgf/sha1cd/cgo/ubc_check.c
--- a/vendor/github.com/pjbgf/sha1cd/cgo/ubc_check.go
+++ b/vendor/github.com/pjbgf/sha1cd/cgo/ubc_check.go
@@ -0,0 +1,28 @@
+package cgo
+
+// #include <ubc_check.h>
+// #include <stdlib.h>
+//
+// uint32_t check(const uint32_t W[80])
+// {
+//	 uint32_t ubc_dv_mask[DVMASKSIZE] = {(uint32_t)(0xFFFFFFFF)};
+//   ubc_check(W, ubc_dv_mask);
+//   return ubc_dv_mask[0];
+// }
+import "C"
+import (
+	"fmt"
+	"unsafe"
+)
+
+// CalculateDvMask takes as input an expanded message block and verifies the unavoidable
+// bitconditions for all listed DVs. It returns a dvmask where each bit belonging to a DV
+// is set if all unavoidable bitconditions for that DV have been met.
+// Thus, one needs to do the recompression check for each DV that has its bit set.
+func CalculateDvMask(W []uint32) (uint32, error) {
+	if len(W) < 80 {
+		return 0, fmt.Errorf("invalid input: len(W) must be 80, was %d", len(W))
+	}
+
+	return uint32(C.check((*C.uint32_t)(unsafe.Pointer(&W[0])))), nil
+}
--- a/vendor/github.com/pjbgf/sha1cd/cgo/ubc_check.h
+++ b/vendor/github.com/pjbgf/sha1cd/cgo/ubc_check.h
@@ -0,0 +1,64 @@
+/***
+ * Copyright 2017 Marc Stevens <marc@marc-stevens.nl>, Dan Shumow <danshu@microsoft.com>
+ * Distributed under the MIT Software License.
+ * See accompanying file LICENSE.txt or copy at
+ * https://opensource.org/licenses/MIT
+ ***/
+
+// Originally from: https://github.com/cr-marcstevens/sha1collisiondetection
+
+/*
+// this file was generated by the 'parse_bitrel' program in the tools section
+// using the data files from directory 'tools/data/3565'
+//
+// sha1_dvs contains a list of SHA-1 Disturbance Vectors (DV) to check
+// dvType, dvK and dvB define the DV: I(K,B) or II(K,B) (see the paper)
+// dm[80] is the expanded message block XOR-difference defined by the DV
+// testt is the step to do the recompression from for collision detection
+// maski and maskb define the bit to check for each DV in the dvmask returned by ubc_check
+//
+// ubc_check takes as input an expanded message block and verifies the unavoidable bitconditions for all listed DVs
+// it returns a dvmask where each bit belonging to a DV is set if all unavoidable bitconditions for that DV have been met
+// thus one needs to do the recompression check for each DV that has its bit set
+*/
+
+#ifndef SHA1DC_UBC_CHECK_H
+#define SHA1DC_UBC_CHECK_H
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+
+#ifndef SHA1DC_NO_STANDARD_INCLUDES
+#include <stdint.h>
+#endif
+
+#define DVMASKSIZE 1
+	typedef struct
+	{
+		int dvType;
+		int dvK;
+		int dvB;
+		int testt;
+		int maski;
+		int maskb;
+		uint32_t dm[80];
+	} dv_info_t;
+	extern dv_info_t sha1_dvs[];
+	void ubc_check(const uint32_t W[80], uint32_t dvmask[DVMASKSIZE]);
+
+#define DOSTORESTATE58
+#define DOSTORESTATE65
+
+#define CHECK_DVMASK(_DVMASK) (0 != _DVMASK[0])
+
+#if defined(__cplusplus)
+}
+#endif
+
+#ifdef SHA1DC_CUSTOM_TRAILING_INCLUDE_UBC_CHECK_H
+#include SHA1DC_CUSTOM_TRAILING_INCLUDE_UBC_CHECK_H
+#endif
+
+#endif
--- a/vendor/github.com/pjbgf/sha1cd/detection.go
+++ b/vendor/github.com/pjbgf/sha1cd/detection.go
@@ -0,0 +1,11 @@
+package sha1cd
+
+import "hash"
+
+type CollisionResistantHash interface {
+	// CollisionResistantSum extends on Sum by returning an additional boolean
+	// which indicates whether a collision was found during the hashing process.
+	CollisionResistantSum(b []byte) ([]byte, bool)
+
+	hash.Hash
+}
--- a/vendor/github.com/pjbgf/sha1cd/sha1block.go
+++ b/vendor/github.com/pjbgf/sha1cd/sha1block.go
@@ -0,0 +1,273 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Originally from: https://github.com/go/blob/master/src/crypto/sha1/sha1block.go
+
+package sha1cd
+
+import (
+	"math/bits"
+
+	"github.com/pjbgf/sha1cd/ubc"
+)
+
+const (
+	msize = 80
+
+	_K0 = 0x5A827999
+	_K1 = 0x6ED9EBA1
+	_K2 = 0x8F1BBCDC
+	_K3 = 0xCA62C1D6
+)
+
+// TODO: Implement SIMD support.
+func block(dig *digest, p []byte) {
+	blockGeneric(dig, p)
+}
+
+// blockGeneric is a portable, pure Go version of the SHA-1 block step.
+// It's used by sha1block_generic.go and tests.
+func blockGeneric(dig *digest, p []byte) {
+	var w [16]uint32
+
+	h0, h1, h2, h3, h4 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4]
+	for len(p) >= chunk {
+		m1 := make([]uint32, msize)
+		bcol := false
+
+		// Can interlace the computation of w with the
+		// rounds below if needed for speed.
+		for i := 0; i < 16; i++ {
+			j := i * 4
+			w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3])
+		}
+
+		a, b, c, d, e := h0, h1, h2, h3, h4
+
+		// Each of the four 20-iteration rounds
+		// differs only in the computation of f and
+		// the choice of K (_K0, _K1, etc).
+		i := 0
+		for ; i < 16; i++ {
+			// Store pre-step compression state for the collision detection.
+			dig.cs[i] = [5]uint32{a, b, c, d, e}
+
+			f := b&c | (^b)&d
+			t := bits.RotateLeft32(a, 5) + f + e + w[i&0xf] + _K0
+			a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
+
+			// Store compression state for the collision detection.
+			m1[i] = w[i&0xf]
+		}
+		for ; i < 20; i++ {
+			// Store pre-step compression state for the collision detection.
+			dig.cs[i] = [5]uint32{a, b, c, d, e}
+
+			tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf]
+			w[i&0xf] = tmp<<1 | tmp>>(32-1)
+
+			f := b&c | (^b)&d
+			t := bits.RotateLeft32(a, 5) + f + e + w[i&0xf] + _K0
+			a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
+
+			// Store compression state for the collision detection.
+			m1[i] = w[i&0xf]
+		}
+		for ; i < 40; i++ {
+			// Store pre-step compression state for the collision detection.
+			dig.cs[i] = [5]uint32{a, b, c, d, e}
+
+			tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf]
+			w[i&0xf] = tmp<<1 | tmp>>(32-1)
+
+			f := b ^ c ^ d
+			t := bits.RotateLeft32(a, 5) + f + e + w[i&0xf] + _K1
+			a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
+
+			// Store compression state for the collision detection.
+			m1[i] = w[i&0xf]
+		}
+		for ; i < 60; i++ {
+			// Store pre-step compression state for the collision detection.
+			dig.cs[i] = [5]uint32{a, b, c, d, e}
+
+			tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf]
+			w[i&0xf] = tmp<<1 | tmp>>(32-1)
+
+			f := ((b | c) & d) | (b & c)
+			t := bits.RotateLeft32(a, 5) + f + e + w[i&0xf] + _K2
+			a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
+
+			// Store compression state for the collision detection.
+			m1[i] = w[i&0xf]
+		}
+		for ; i < 80; i++ {
+			// Store pre-step compression state for the collision detection.
+			dig.cs[i] = [5]uint32{a, b, c, d, e}
+
+			tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf]
+			w[i&0xf] = tmp<<1 | tmp>>(32-1)
+
+			f := b ^ c ^ d
+			t := bits.RotateLeft32(a, 5) + f + e + w[i&0xf] + _K3
+			a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
+
+			// Store compression state for the collision detection.
+			m1[i] = w[i&0xf]
+		}
+
+		h0 += a
+		h1 += b
+		h2 += c
+		h3 += d
+		h4 += e
+
+		if mask, err := ubc.CalculateDvMask(m1); err == nil && mask != 0 {
+			dvs := ubc.SHA1_dvs()
+			for i := 0; dvs[i].DvType != 0; i++ {
+				if (mask & ((uint32)(1) << uint32(dvs[i].MaskB))) != 0 {
+					for j := 0; j < msize; j++ {
+						dig.m2[j] = m1[j] ^ dvs[i].Dm[j]
+					}
+
+					recompressionStep(dvs[i].TestT, &dig.ihv2, &dig.ihvtmp, dig.m2, dig.cs[dvs[i].TestT])
+
+					if 0 == ((dig.ihvtmp[0] ^ h0) | (dig.ihvtmp[1] ^ h1) |
+						(dig.ihvtmp[2] ^ h2) | (dig.ihvtmp[3] ^ h3) | (dig.ihvtmp[4] ^ h4)) {
+						dig.col = true
+						bcol = true
+					}
+				}
+			}
+		}
+
+		// Collision attacks are thwarted by hashing a detected near-collision block 3 times.
+		// Think of it as extending SHA-1 from 80-steps to 240-steps for such blocks:
+		// 		The best collision attacks against SHA-1 have complexity about 2^60,
+		// 		thus for 240-steps an immediate lower-bound for the best cryptanalytic attacks would be 2^180.
+		// 		An attacker would be better off using a generic birthday search of complexity 2^80.
+		if bcol {
+			for j := 0; j < 2; j++ {
+				a, b, c, d, e := h0, h1, h2, h3, h4
+
+				i := 0
+				for ; i < 20; i++ {
+					f := b&c | (^b)&d
+					t := bits.RotateLeft32(a, 5) + f + e + m1[i] + _K0
+					a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
+				}
+				for ; i < 40; i++ {
+					f := b ^ c ^ d
+					t := bits.RotateLeft32(a, 5) + f + e + m1[i] + _K1
+					a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
+				}
+				for ; i < 60; i++ {
+					f := ((b | c) & d) | (b & c)
+					t := bits.RotateLeft32(a, 5) + f + e + m1[i] + _K2
+					a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
+				}
+				for ; i < 80; i++ {
+					f := b ^ c ^ d
+					t := bits.RotateLeft32(a, 5) + f + e + m1[i] + _K3
+					a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
+				}
+
+				h0 += a
+				h1 += b
+				h2 += c
+				h3 += d
+				h4 += e
+			}
+		}
+
+		p = p[chunk:]
+	}
+
+	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4] = h0, h1, h2, h3, h4
+}
+
+func recompressionStep(step int, ihvin, ihvout *[5]uint32, m2 [msize]uint32, state [5]uint32) {
+	a, b, c, d, e := state[0], state[1], state[2], state[3], state[4]
+
+	// Walk backwards from current step to undo previous compression.
+	for i := 79; i >= 60; i-- {
+		a, b, c, d, e = b, c, d, e, a
+		if step > i {
+			b = bits.RotateLeft32(b, -30)
+			f := b ^ c ^ d
+			e -= bits.RotateLeft32(a, 5) + f + _K3 + m2[i]
+		}
+	}
+	for i := 59; i >= 40; i-- {
+		a, b, c, d, e = b, c, d, e, a
+		if step > i {
+			b = bits.RotateLeft32(b, -30)
+			f := ((b | c) & d) | (b & c)
+			e -= bits.RotateLeft32(a, 5) + f + _K2 + m2[i]
+		}
+	}
+	for i := 39; i >= 20; i-- {
+		a, b, c, d, e = b, c, d, e, a
+		if step > i {
+			b = bits.RotateLeft32(b, -30)
+			f := b ^ c ^ d
+			e -= bits.RotateLeft32(a, 5) + f + _K1 + m2[i]
+		}
+	}
+	for i := 19; i >= 0; i-- {
+		a, b, c, d, e = b, c, d, e, a
+		if step > i {
+			b = bits.RotateLeft32(b, -30)
+			f := b&c | (^b)&d
+			e -= bits.RotateLeft32(a, 5) + f + _K0 + m2[i]
+		}
+	}
+
+	ihvin[0] = a
+	ihvin[1] = b
+	ihvin[2] = c
+	ihvin[3] = d
+	ihvin[4] = e
+	a = state[0]
+	b = state[1]
+	c = state[2]
+	d = state[3]
+	e = state[4]
+
+	// Recompress blocks based on the current step.
+	for i := 0; i < 20; i++ {
+		if step <= i {
+			f := b&c | (^b)&d
+			t := bits.RotateLeft32(a, 5) + f + e + _K0 + m2[i]
+			a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
+		}
+	}
+	for i := 20; i < 40; i++ {
+		if step <= i {
+			f := b ^ c ^ d
+			t := bits.RotateLeft32(a, 5) + f + e + _K1 + m2[i]
+			a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
+		}
+	}
+	for i := 40; i < 60; i++ {
+		if step <= i {
+			f := ((b | c) & d) | (b & c)
+			t := bits.RotateLeft32(a, 5) + f + e + _K2 + m2[i]
+			a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
+		}
+	}
+	for i := 60; i < 80; i++ {
+		if step <= i {
+			f := b ^ c ^ d
+			t := bits.RotateLeft32(a, 5) + f + e + _K3 + m2[i]
+			a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
+		}
+	}
+
+	ihvout[0] = ihvin[0] + a
+	ihvout[1] = ihvin[1] + b
+	ihvout[2] = ihvin[2] + c
+	ihvout[3] = ihvin[3] + d
+	ihvout[4] = ihvin[4] + e
+}
--- a/vendor/github.com/pjbgf/sha1cd/sha1cd.go
+++ b/vendor/github.com/pjbgf/sha1cd/sha1cd.go
@@ -0,0 +1,328 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package sha1cd implements collision detection based on the whitepaper
+// Counter-cryptanalysis from Marc Stevens. The original ubc implementation
+// was done by Marc Stevens and Dan Shumow, and can be found at:
+// https://github.com/cr-marcstevens/sha1collisiondetection
+package sha1cd
+
+// This SHA1 implementation is based on Go's generic SHA1.
+// Original: https://github.com/golang/go/blob/master/src/crypto/sha1/sha1.go
+
+import (
+	"crypto"
+	"encoding/binary"
+	"errors"
+	"hash"
+)
+
+func init() {
+	crypto.RegisterHash(crypto.SHA1, New)
+}
+
+// The size of a SHA-1 checksum in bytes.
+const Size = 20
+
+// The blocksize of SHA-1 in bytes.
+const BlockSize = 64
+
+const (
+	chunk = 64
+	init0 = 0x67452301
+	init1 = 0xEFCDAB89
+	init2 = 0x98BADCFE
+	init3 = 0x10325476
+	init4 = 0xC3D2E1F0
+)
+
+// digest represents the partial evaluation of a checksum.
+type digest struct {
+	h   [5]uint32
+	x   [chunk]byte
+	nx  int
+	len uint64
+
+	// col defines whether a collision has been found.
+	col bool
+	// cs stores the compression state for each of the SHA1's 80 steps.
+	cs map[int][5]uint32
+	// m2 is a secondary message created XORing with ubc's DM prior to the SHA recompression step.
+	m2 [msize]uint32
+	// ihv2 is an Intermediary Hash Value created during the SHA recompression step.
+	ihv2 [5]uint32
+	// ihvtmp is an Intermediary Hash Value created during the SHA recompression step.
+	ihvtmp [5]uint32
+}
+
+const (
+	magic         = "shacd\x01"
+	marshaledSize = len(magic) + 5*4 + chunk + 8
+)
+
+func (d *digest) MarshalBinary() ([]byte, error) {
+	b := make([]byte, 0, marshaledSize)
+	b = append(b, magic...)
+	b = appendUint32(b, d.h[0])
+	b = appendUint32(b, d.h[1])
+	b = appendUint32(b, d.h[2])
+	b = appendUint32(b, d.h[3])
+	b = appendUint32(b, d.h[4])
+	b = append(b, d.x[:d.nx]...)
+	b = b[:len(b)+len(d.x)-d.nx] // already zero
+	b = appendUint64(b, d.len)
+	return b, nil
+}
+
+func appendUint32(b []byte, v uint32) []byte {
+	return append(b,
+		byte(v>>24),
+		byte(v>>16),
+		byte(v>>8),
+		byte(v),
+	)
+}
+
+func appendUint64(b []byte, v uint64) []byte {
+	return append(b,
+		byte(v>>56),
+		byte(v>>48),
+		byte(v>>40),
+		byte(v>>32),
+		byte(v>>24),
+		byte(v>>16),
+		byte(v>>8),
+		byte(v),
+	)
+}
+
+func (d *digest) UnmarshalBinary(b []byte) error {
+	if len(b) < len(magic) || string(b[:len(magic)]) != magic {
+		return errors.New("crypto/sha1: invalid hash state identifier")
+	}
+	if len(b) != marshaledSize {
+		return errors.New("crypto/sha1: invalid hash state size")
+	}
+	b = b[len(magic):]
+	b, d.h[0] = consumeUint32(b)
+	b, d.h[1] = consumeUint32(b)
+	b, d.h[2] = consumeUint32(b)
+	b, d.h[3] = consumeUint32(b)
+	b, d.h[4] = consumeUint32(b)
+	b = b[copy(d.x[:], b):]
+	b, d.len = consumeUint64(b)
+	d.nx = int(d.len % chunk)
+	return nil
+}
+
+func consumeUint64(b []byte) ([]byte, uint64) {
+	_ = b[7]
+	x := uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |
+		uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56
+	return b[8:], x
+}
+
+func consumeUint32(b []byte) ([]byte, uint32) {
+	_ = b[3]
+	x := uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
+	return b[4:], x
+}
+
+func (d *digest) Reset() {
+	d.h[0] = init0
+	d.h[1] = init1
+	d.h[2] = init2
+	d.h[3] = init3
+	d.h[4] = init4
+	d.nx = 0
+	d.len = 0
+
+	d.col = false
+	d.ihv2[0] = 0x0
+	d.ihv2[1] = 0x0
+	d.ihv2[2] = 0x0
+	d.ihv2[3] = 0x0
+	d.ihv2[4] = 0x0
+
+	d.ihvtmp[0] = 0xD5
+	d.ihvtmp[1] = 0x394
+	d.ihvtmp[2] = 0x8152A8
+	d.ihvtmp[3] = 0x0
+	d.ihvtmp[4] = 0xA7ECE0
+
+	for i := range d.m2 {
+		d.m2[i] = 0x0
+	}
+
+	for k := range d.cs {
+		delete(d.cs, k)
+	}
+}
+
+// New returns a new hash.Hash computing the SHA1 checksum. The Hash also
+// implements encoding.BinaryMarshaler and encoding.BinaryUnmarshaler to
+// marshal and unmarshal the internal state of the hash.
+func New() hash.Hash {
+	d := new(digest)
+
+	d.cs = map[int][5]uint32{}
+	d.m2 = [msize]uint32{}
+
+	d.Reset()
+	return d
+}
+
+func (d *digest) Size() int { return Size }
+
+func (d *digest) BlockSize() int { return BlockSize }
+
+func (d *digest) Write(p []byte) (nn int, err error) {
+	if len(p) == 0 {
+		return
+	}
+
+	nn = len(p)
+	d.len += uint64(nn)
+	if d.nx > 0 {
+		n := copy(d.x[d.nx:], p)
+		d.nx += n
+		if d.nx == chunk {
+			block(d, d.x[:])
+			d.nx = 0
+		}
+		p = p[n:]
+	}
+	if len(p) >= chunk {
+		n := len(p) &^ (chunk - 1)
+		block(d, p[:n])
+		p = p[n:]
+	}
+	if len(p) > 0 {
+		d.nx = copy(d.x[:], p)
+	}
+	return
+}
+
+func (d *digest) Sum(in []byte) []byte {
+	// Make a copy of d so that caller can keep writing and summing.
+	d0 := *d
+	hash := d0.checkSum()
+	return append(in, hash[:]...)
+}
+
+func (d *digest) checkSum() [Size]byte {
+	len := d.len
+	// Padding.  Add a 1 bit and 0 bits until 56 bytes mod 64.
+	var tmp [64]byte
+	tmp[0] = 0x80
+	if len%64 < 56 {
+		d.Write(tmp[0 : 56-len%64])
+	} else {
+		d.Write(tmp[0 : 64+56-len%64])
+	}
+
+	// Length in bits.
+	len <<= 3
+	binary.BigEndian.PutUint64(tmp[:], len)
+	d.Write(tmp[0:8])
+
+	if d.nx != 0 {
+		panic("d.nx != 0")
+	}
+
+	var digest [Size]byte
+
+	binary.BigEndian.PutUint32(digest[0:], d.h[0])
+	binary.BigEndian.PutUint32(digest[4:], d.h[1])
+	binary.BigEndian.PutUint32(digest[8:], d.h[2])
+	binary.BigEndian.PutUint32(digest[12:], d.h[3])
+	binary.BigEndian.PutUint32(digest[16:], d.h[4])
+
+	return digest
+}
+
+// ConstantTimeSum computes the same result of Sum() but in constant time
+func (d *digest) ConstantTimeSum(in []byte) ([]byte, error) {
+	d0 := *d
+	hash, err := d0.constSum()
+	if err != nil {
+		return nil, err
+	}
+	return append(in, hash[:]...), nil
+}
+
+func (d *digest) constSum() ([Size]byte, error) {
+	var length [8]byte
+	l := d.len << 3
+	for i := uint(0); i < 8; i++ {
+		length[i] = byte(l >> (56 - 8*i))
+	}
+
+	nx := byte(d.nx)
+	t := nx - 56                 // if nx < 56 then the MSB of t is one
+	mask1b := byte(int8(t) >> 7) // mask1b is 0xFF iff one block is enough
+
+	separator := byte(0x80) // gets reset to 0x00 once used
+	for i := byte(0); i < chunk; i++ {
+		mask := byte(int8(i-nx) >> 7) // 0x00 after the end of data
+
+		// if we reached the end of the data, replace with 0x80 or 0x00
+		d.x[i] = (^mask & separator) | (mask & d.x[i])
+
+		// zero the separator once used
+		separator &= mask
+
+		if i >= 56 {
+			// we might have to write the length here if all fit in one block
+			d.x[i] |= mask1b & length[i-56]
+		}
+	}
+
+	// compress, and only keep the digest if all fit in one block
+	block(d, d.x[:])
+
+	var digest [Size]byte
+	for i, s := range d.h {
+		digest[i*4] = mask1b & byte(s>>24)
+		digest[i*4+1] = mask1b & byte(s>>16)
+		digest[i*4+2] = mask1b & byte(s>>8)
+		digest[i*4+3] = mask1b & byte(s)
+	}
+
+	for i := byte(0); i < chunk; i++ {
+		// second block, it's always past the end of data, might start with 0x80
+		if i < 56 {
+			d.x[i] = separator
+			separator = 0
+		} else {
+			d.x[i] = length[i-56]
+		}
+	}
+
+	// compress, and only keep the digest if we actually needed the second block
+	block(d, d.x[:])
+
+	for i, s := range d.h {
+		digest[i*4] |= ^mask1b & byte(s>>24)
+		digest[i*4+1] |= ^mask1b & byte(s>>16)
+		digest[i*4+2] |= ^mask1b & byte(s>>8)
+		digest[i*4+3] |= ^mask1b & byte(s)
+	}
+
+	return digest, nil
+}
+
+// Sum returns the SHA-1 checksum of the data.
+func Sum(data []byte) ([Size]byte, bool) {
+	d := New().(*digest)
+	d.Write(data)
+	return d.checkSum(), d.col
+}
+
+func (d *digest) CollisionResistantSum(in []byte) ([]byte, bool) {
+	// Make a copy of d so that caller can keep writing and summing.
+	d0 := *d
+	hash := d0.checkSum()
+	return append(in, hash[:]...), d0.col
+}
--- a/vendor/github.com/pjbgf/sha1cd/ubc/check.go
+++ b/vendor/github.com/pjbgf/sha1cd/ubc/check.go
@@ -0,0 +1,374 @@
+// Based on the C implementation from Marc Stevens and Dan Shumow.
+// https://github.com/cr-marcstevens/sha1collisiondetection
+
+package ubc
+
+import "fmt"
+
+type DvInfo struct {
+	// DvType, DvK and DvB define the DV: I(K,B) or II(K,B) (see the paper).
+	// https://marc-stevens.nl/research/papers/C13-S.pdf
+	DvType int
+	DvK    int
+	DvB    int
+
+	// TestT is the step to do the recompression from for collision detection.
+	TestT int
+
+	// MaskI and MaskB define the bit to check for each DV in the dvmask returned by ubc_check.
+	MaskI int
+	MaskB int
+
+	// Dm is the expanded message block XOR-difference defined by the DV.
+	Dm [80]uint32
+}
+
+// Check takes as input an expanded message block and verifies the unavoidable bitconditions
+// for all listed DVs. It returns a dvmask where each bit belonging to a DV is set if all
+// unavoidable bitconditions for that DV have been met.
+// Thus, one needs to do the recompression check for each DV that has its bit set.
+func CalculateDvMask(W []uint32) (uint32, error) {
+	if len(W) < 80 {
+		return 0, fmt.Errorf("invalid input: len(W) must be 80, was %d", len(W))
+	}
+
+	mask := uint32(0xFFFFFFFF)
+	mask &= (((((W[44] ^ W[45]) >> 29) & 1) - 1) | ^(DV_I_48_0_bit | DV_I_51_0_bit | DV_I_52_0_bit | DV_II_45_0_bit | DV_II_46_0_bit | DV_II_50_0_bit | DV_II_51_0_bit))
+	mask &= (((((W[49] ^ W[50]) >> 29) & 1) - 1) | ^(DV_I_46_0_bit | DV_II_45_0_bit | DV_II_50_0_bit | DV_II_51_0_bit | DV_II_55_0_bit | DV_II_56_0_bit))
+	mask &= (((((W[48] ^ W[49]) >> 29) & 1) - 1) | ^(DV_I_45_0_bit | DV_I_52_0_bit | DV_II_49_0_bit | DV_II_50_0_bit | DV_II_54_0_bit | DV_II_55_0_bit))
+	mask &= ((((W[47] ^ (W[50] >> 25)) & (1 << 4)) - (1 << 4)) | ^(DV_I_47_0_bit | DV_I_49_0_bit | DV_I_51_0_bit | DV_II_45_0_bit | DV_II_51_0_bit | DV_II_56_0_bit))
+	mask &= (((((W[47] ^ W[48]) >> 29) & 1) - 1) | ^(DV_I_44_0_bit | DV_I_51_0_bit | DV_II_48_0_bit | DV_II_49_0_bit | DV_II_53_0_bit | DV_II_54_0_bit))
+	mask &= (((((W[46] >> 4) ^ (W[49] >> 29)) & 1) - 1) | ^(DV_I_46_0_bit | DV_I_48_0_bit | DV_I_50_0_bit | DV_I_52_0_bit | DV_II_50_0_bit | DV_II_55_0_bit))
+	mask &= (((((W[46] ^ W[47]) >> 29) & 1) - 1) | ^(DV_I_43_0_bit | DV_I_50_0_bit | DV_II_47_0_bit | DV_II_48_0_bit | DV_II_52_0_bit | DV_II_53_0_bit))
+	mask &= (((((W[45] >> 4) ^ (W[48] >> 29)) & 1) - 1) | ^(DV_I_45_0_bit | DV_I_47_0_bit | DV_I_49_0_bit | DV_I_51_0_bit | DV_II_49_0_bit | DV_II_54_0_bit))
+	mask &= (((((W[45] ^ W[46]) >> 29) & 1) - 1) | ^(DV_I_49_0_bit | DV_I_52_0_bit | DV_II_46_0_bit | DV_II_47_0_bit | DV_II_51_0_bit | DV_II_52_0_bit))
+	mask &= (((((W[44] >> 4) ^ (W[47] >> 29)) & 1) - 1) | ^(DV_I_44_0_bit | DV_I_46_0_bit | DV_I_48_0_bit | DV_I_50_0_bit | DV_II_48_0_bit | DV_II_53_0_bit))
+	mask &= (((((W[43] >> 4) ^ (W[46] >> 29)) & 1) - 1) | ^(DV_I_43_0_bit | DV_I_45_0_bit | DV_I_47_0_bit | DV_I_49_0_bit | DV_II_47_0_bit | DV_II_52_0_bit))
+	mask &= (((((W[43] ^ W[44]) >> 29) & 1) - 1) | ^(DV_I_47_0_bit | DV_I_50_0_bit | DV_I_51_0_bit | DV_II_45_0_bit | DV_II_49_0_bit | DV_II_50_0_bit))
+	mask &= (((((W[42] >> 4) ^ (W[45] >> 29)) & 1) - 1) | ^(DV_I_44_0_bit | DV_I_46_0_bit | DV_I_48_0_bit | DV_I_52_0_bit | DV_II_46_0_bit | DV_II_51_0_bit))
+	mask &= (((((W[41] >> 4) ^ (W[44] >> 29)) & 1) - 1) | ^(DV_I_43_0_bit | DV_I_45_0_bit | DV_I_47_0_bit | DV_I_51_0_bit | DV_II_45_0_bit | DV_II_50_0_bit))
+	mask &= (((((W[40] ^ W[41]) >> 29) & 1) - 1) | ^(DV_I_44_0_bit | DV_I_47_0_bit | DV_I_48_0_bit | DV_II_46_0_bit | DV_II_47_0_bit | DV_II_56_0_bit))
+	mask &= (((((W[54] ^ W[55]) >> 29) & 1) - 1) | ^(DV_I_51_0_bit | DV_II_47_0_bit | DV_II_50_0_bit | DV_II_55_0_bit | DV_II_56_0_bit))
+	mask &= (((((W[53] ^ W[54]) >> 29) & 1) - 1) | ^(DV_I_50_0_bit | DV_II_46_0_bit | DV_II_49_0_bit | DV_II_54_0_bit | DV_II_55_0_bit))
+	mask &= (((((W[52] ^ W[53]) >> 29) & 1) - 1) | ^(DV_I_49_0_bit | DV_II_45_0_bit | DV_II_48_0_bit | DV_II_53_0_bit | DV_II_54_0_bit))
+	mask &= ((((W[50] ^ (W[53] >> 25)) & (1 << 4)) - (1 << 4)) | ^(DV_I_50_0_bit | DV_I_52_0_bit | DV_II_46_0_bit | DV_II_48_0_bit | DV_II_54_0_bit))
+	mask &= (((((W[50] ^ W[51]) >> 29) & 1) - 1) | ^(DV_I_47_0_bit | DV_II_46_0_bit | DV_II_51_0_bit | DV_II_52_0_bit | DV_II_56_0_bit))
+	mask &= ((((W[49] ^ (W[52] >> 25)) & (1 << 4)) - (1 << 4)) | ^(DV_I_49_0_bit | DV_I_51_0_bit | DV_II_45_0_bit | DV_II_47_0_bit | DV_II_53_0_bit))
+	mask &= ((((W[48] ^ (W[51] >> 25)) & (1 << 4)) - (1 << 4)) | ^(DV_I_48_0_bit | DV_I_50_0_bit | DV_I_52_0_bit | DV_II_46_0_bit | DV_II_52_0_bit))
+	mask &= (((((W[42] ^ W[43]) >> 29) & 1) - 1) | ^(DV_I_46_0_bit | DV_I_49_0_bit | DV_I_50_0_bit | DV_II_48_0_bit | DV_II_49_0_bit))
+	mask &= (((((W[41] ^ W[42]) >> 29) & 1) - 1) | ^(DV_I_45_0_bit | DV_I_48_0_bit | DV_I_49_0_bit | DV_II_47_0_bit | DV_II_48_0_bit))
+	mask &= (((((W[40] >> 4) ^ (W[43] >> 29)) & 1) - 1) | ^(DV_I_44_0_bit | DV_I_46_0_bit | DV_I_50_0_bit | DV_II_49_0_bit | DV_II_56_0_bit))
+	mask &= (((((W[39] >> 4) ^ (W[42] >> 29)) & 1) - 1) | ^(DV_I_43_0_bit | DV_I_45_0_bit | DV_I_49_0_bit | DV_II_48_0_bit | DV_II_55_0_bit))
+
+	if (mask & (DV_I_44_0_bit | DV_I_48_0_bit | DV_II_47_0_bit | DV_II_54_0_bit | DV_II_56_0_bit)) != 0 {
+		mask &= (((((W[38] >> 4) ^ (W[41] >> 29)) & 1) - 1) | ^(DV_I_44_0_bit | DV_I_48_0_bit | DV_II_47_0_bit | DV_II_54_0_bit | DV_II_56_0_bit))
+	}
+	mask &= (((((W[37] >> 4) ^ (W[40] >> 29)) & 1) - 1) | ^(DV_I_43_0_bit | DV_I_47_0_bit | DV_II_46_0_bit | DV_II_53_0_bit | DV_II_55_0_bit))
+	if (mask & (DV_I_52_0_bit | DV_II_48_0_bit | DV_II_51_0_bit | DV_II_56_0_bit)) != 0 {
+		mask &= (((((W[55] ^ W[56]) >> 29) & 1) - 1) | ^(DV_I_52_0_bit | DV_II_48_0_bit | DV_II_51_0_bit | DV_II_56_0_bit))
+	}
+	if (mask & (DV_I_52_0_bit | DV_II_48_0_bit | DV_II_50_0_bit | DV_II_56_0_bit)) != 0 {
+		mask &= ((((W[52] ^ (W[55] >> 25)) & (1 << 4)) - (1 << 4)) | ^(DV_I_52_0_bit | DV_II_48_0_bit | DV_II_50_0_bit | DV_II_56_0_bit))
+	}
+	if (mask & (DV_I_51_0_bit | DV_II_47_0_bit | DV_II_49_0_bit | DV_II_55_0_bit)) != 0 {
+		mask &= ((((W[51] ^ (W[54] >> 25)) & (1 << 4)) - (1 << 4)) | ^(DV_I_51_0_bit | DV_II_47_0_bit | DV_II_49_0_bit | DV_II_55_0_bit))
+	}
+	if (mask & (DV_I_48_0_bit | DV_II_47_0_bit | DV_II_52_0_bit | DV_II_53_0_bit)) != 0 {
+		mask &= (((((W[51] ^ W[52]) >> 29) & 1) - 1) | ^(DV_I_48_0_bit | DV_II_47_0_bit | DV_II_52_0_bit | DV_II_53_0_bit))
+	}
+	if (mask & (DV_I_46_0_bit | DV_I_49_0_bit | DV_II_45_0_bit | DV_II_48_0_bit)) != 0 {
+		mask &= (((((W[36] >> 4) ^ (W[40] >> 29)) & 1) - 1) | ^(DV_I_46_0_bit | DV_I_49_0_bit | DV_II_45_0_bit | DV_II_48_0_bit))
+	}
+	if (mask & (DV_I_52_0_bit | DV_II_48_0_bit | DV_II_49_0_bit)) != 0 {
+		mask &= ((0 - (((W[53] ^ W[56]) >> 29) & 1)) | ^(DV_I_52_0_bit | DV_II_48_0_bit | DV_II_49_0_bit))
+	}
+	if (mask & (DV_I_50_0_bit | DV_II_46_0_bit | DV_II_47_0_bit)) != 0 {
+		mask &= ((0 - (((W[51] ^ W[54]) >> 29) & 1)) | ^(DV_I_50_0_bit | DV_II_46_0_bit | DV_II_47_0_bit))
+	}
+	if (mask & (DV_I_49_0_bit | DV_I_51_0_bit | DV_II_45_0_bit)) != 0 {
+		mask &= ((0 - (((W[50] ^ W[52]) >> 29) & 1)) | ^(DV_I_49_0_bit | DV_I_51_0_bit | DV_II_45_0_bit))
+	}
+	if (mask & (DV_I_48_0_bit | DV_I_50_0_bit | DV_I_52_0_bit)) != 0 {
+		mask &= ((0 - (((W[49] ^ W[51]) >> 29) & 1)) | ^(DV_I_48_0_bit | DV_I_50_0_bit | DV_I_52_0_bit))
+	}
+	if (mask & (DV_I_47_0_bit | DV_I_49_0_bit | DV_I_51_0_bit)) != 0 {
+		mask &= ((0 - (((W[48] ^ W[50]) >> 29) & 1)) | ^(DV_I_47_0_bit | DV_I_49_0_bit | DV_I_51_0_bit))
+	}
+	if (mask & (DV_I_46_0_bit | DV_I_48_0_bit | DV_I_50_0_bit)) != 0 {
+		mask &= ((0 - (((W[47] ^ W[49]) >> 29) & 1)) | ^(DV_I_46_0_bit | DV_I_48_0_bit | DV_I_50_0_bit))
+	}
+	if (mask & (DV_I_45_0_bit | DV_I_47_0_bit | DV_I_49_0_bit)) != 0 {
+		mask &= ((0 - (((W[46] ^ W[48]) >> 29) & 1)) | ^(DV_I_45_0_bit | DV_I_47_0_bit | DV_I_49_0_bit))
+	}
+	mask &= ((((W[45] ^ W[47]) & (1 << 6)) - (1 << 6)) | ^(DV_I_47_2_bit | DV_I_49_2_bit | DV_I_51_2_bit))
+	if (mask & (DV_I_44_0_bit | DV_I_46_0_bit | DV_I_48_0_bit)) != 0 {
+		mask &= ((0 - (((W[45] ^ W[47]) >> 29) & 1)) | ^(DV_I_44_0_bit | DV_I_46_0_bit | DV_I_48_0_bit))
+	}
+	mask &= (((((W[44] ^ W[46]) >> 6) & 1) - 1) | ^(DV_I_46_2_bit | DV_I_48_2_bit | DV_I_50_2_bit))
+	if (mask & (DV_I_43_0_bit | DV_I_45_0_bit | DV_I_47_0_bit)) != 0 {
+		mask &= ((0 - (((W[44] ^ W[46]) >> 29) & 1)) | ^(DV_I_43_0_bit | DV_I_45_0_bit | DV_I_47_0_bit))
+	}
+	mask &= ((0 - ((W[41] ^ (W[42] >> 5)) & (1 << 1))) | ^(DV_I_48_2_bit | DV_II_46_2_bit | DV_II_51_2_bit))
+	mask &= ((0 - ((W[40] ^ (W[41] >> 5)) & (1 << 1))) | ^(DV_I_47_2_bit | DV_I_51_2_bit | DV_II_50_2_bit))
+	if (mask & (DV_I_44_0_bit | DV_I_46_0_bit | DV_II_56_0_bit)) != 0 {
+		mask &= ((0 - (((W[40] ^ W[42]) >> 4) & 1)) | ^(DV_I_44_0_bit | DV_I_46_0_bit | DV_II_56_0_bit))
+	}
+	mask &= ((0 - ((W[39] ^ (W[40] >> 5)) & (1 << 1))) | ^(DV_I_46_2_bit | DV_I_50_2_bit | DV_II_49_2_bit))
+	if (mask & (DV_I_43_0_bit | DV_I_45_0_bit | DV_II_55_0_bit)) != 0 {
+		mask &= ((0 - (((W[39] ^ W[41]) >> 4) & 1)) | ^(DV_I_43_0_bit | DV_I_45_0_bit | DV_II_55_0_bit))
+	}
+	if (mask & (DV_I_44_0_bit | DV_II_54_0_bit | DV_II_56_0_bit)) != 0 {
+		mask &= ((0 - (((W[38] ^ W[40]) >> 4) & 1)) | ^(DV_I_44_0_bit | DV_II_54_0_bit | DV_II_56_0_bit))
+	}
+	if (mask & (DV_I_43_0_bit | DV_II_53_0_bit | DV_II_55_0_bit)) != 0 {
+		mask &= ((0 - (((W[37] ^ W[39]) >> 4) & 1)) | ^(DV_I_43_0_bit | DV_II_53_0_bit | DV_II_55_0_bit))
+	}
+	mask &= ((0 - ((W[36] ^ (W[37] >> 5)) & (1 << 1))) | ^(DV_I_47_2_bit | DV_I_50_2_bit | DV_II_46_2_bit))
+	if (mask & (DV_I_45_0_bit | DV_I_48_0_bit | DV_II_47_0_bit)) != 0 {
+		mask &= (((((W[35] >> 4) ^ (W[39] >> 29)) & 1) - 1) | ^(DV_I_45_0_bit | DV_I_48_0_bit | DV_II_47_0_bit))
+	}
+	if (mask & (DV_I_48_0_bit | DV_II_48_0_bit)) != 0 {
+		mask &= ((0 - ((W[63] ^ (W[64] >> 5)) & (1 << 0))) | ^(DV_I_48_0_bit | DV_II_48_0_bit))
+	}
+	if (mask & (DV_I_45_0_bit | DV_II_45_0_bit)) != 0 {
+		mask &= ((0 - ((W[63] ^ (W[64] >> 5)) & (1 << 1))) | ^(DV_I_45_0_bit | DV_II_45_0_bit))
+	}
+	if (mask & (DV_I_47_0_bit | DV_II_47_0_bit)) != 0 {
+		mask &= ((0 - ((W[62] ^ (W[63] >> 5)) & (1 << 0))) | ^(DV_I_47_0_bit | DV_II_47_0_bit))
+	}
+	if (mask & (DV_I_46_0_bit | DV_II_46_0_bit)) != 0 {
+		mask &= ((0 - ((W[61] ^ (W[62] >> 5)) & (1 << 0))) | ^(DV_I_46_0_bit | DV_II_46_0_bit))
+	}
+	mask &= ((0 - ((W[61] ^ (W[62] >> 5)) & (1 << 2))) | ^(DV_I_46_2_bit | DV_II_46_2_bit))
+	if (mask & (DV_I_45_0_bit | DV_II_45_0_bit)) != 0 {
+		mask &= ((0 - ((W[60] ^ (W[61] >> 5)) & (1 << 0))) | ^(DV_I_45_0_bit | DV_II_45_0_bit))
+	}
+	if (mask & (DV_II_51_0_bit | DV_II_54_0_bit)) != 0 {
+		mask &= (((((W[58] ^ W[59]) >> 29) & 1) - 1) | ^(DV_II_51_0_bit | DV_II_54_0_bit))
+	}
+	if (mask & (DV_II_50_0_bit | DV_II_53_0_bit)) != 0 {
+		mask &= (((((W[57] ^ W[58]) >> 29) & 1) - 1) | ^(DV_II_50_0_bit | DV_II_53_0_bit))
+	}
+	if (mask & (DV_II_52_0_bit | DV_II_54_0_bit)) != 0 {
+		mask &= ((((W[56] ^ (W[59] >> 25)) & (1 << 4)) - (1 << 4)) | ^(DV_II_52_0_bit | DV_II_54_0_bit))
+	}
+	if (mask & (DV_II_51_0_bit | DV_II_52_0_bit)) != 0 {
+		mask &= ((0 - (((W[56] ^ W[59]) >> 29) & 1)) | ^(DV_II_51_0_bit | DV_II_52_0_bit))
+	}
+	if (mask & (DV_II_49_0_bit | DV_II_52_0_bit)) != 0 {
+		mask &= (((((W[56] ^ W[57]) >> 29) & 1) - 1) | ^(DV_II_49_0_bit | DV_II_52_0_bit))
+	}
+	if (mask & (DV_II_51_0_bit | DV_II_53_0_bit)) != 0 {
+		mask &= ((((W[55] ^ (W[58] >> 25)) & (1 << 4)) - (1 << 4)) | ^(DV_II_51_0_bit | DV_II_53_0_bit))
+	}
+	if (mask & (DV_II_50_0_bit | DV_II_52_0_bit)) != 0 {
+		mask &= ((((W[54] ^ (W[57] >> 25)) & (1 << 4)) - (1 << 4)) | ^(DV_II_50_0_bit | DV_II_52_0_bit))
+	}
+	if (mask & (DV_II_49_0_bit | DV_II_51_0_bit)) != 0 {
+		mask &= ((((W[53] ^ (W[56] >> 25)) & (1 << 4)) - (1 << 4)) | ^(DV_II_49_0_bit | DV_II_51_0_bit))
+	}
+	mask &= ((((W[51] ^ (W[50] >> 5)) & (1 << 1)) - (1 << 1)) | ^(DV_I_50_2_bit | DV_II_46_2_bit))
+	mask &= ((((W[48] ^ W[50]) & (1 << 6)) - (1 << 6)) | ^(DV_I_50_2_bit | DV_II_46_2_bit))
+	if (mask & (DV_I_51_0_bit | DV_I_52_0_bit)) != 0 {
+		mask &= ((0 - (((W[48] ^ W[55]) >> 29) & 1)) | ^(DV_I_51_0_bit | DV_I_52_0_bit))
+	}
+	mask &= ((((W[47] ^ W[49]) & (1 << 6)) - (1 << 6)) | ^(DV_I_49_2_bit | DV_I_51_2_bit))
+	mask &= ((((W[48] ^ (W[47] >> 5)) & (1 << 1)) - (1 << 1)) | ^(DV_I_47_2_bit | DV_II_51_2_bit))
+	mask &= ((((W[46] ^ W[48]) & (1 << 6)) - (1 << 6)) | ^(DV_I_48_2_bit | DV_I_50_2_bit))
+	mask &= ((((W[47] ^ (W[46] >> 5)) & (1 << 1)) - (1 << 1)) | ^(DV_I_46_2_bit | DV_II_50_2_bit))
+	mask &= ((0 - ((W[44] ^ (W[45] >> 5)) & (1 << 1))) | ^(DV_I_51_2_bit | DV_II_49_2_bit))
+	mask &= ((((W[43] ^ W[45]) & (1 << 6)) - (1 << 6)) | ^(DV_I_47_2_bit | DV_I_49_2_bit))
+	mask &= (((((W[42] ^ W[44]) >> 6) & 1) - 1) | ^(DV_I_46_2_bit | DV_I_48_2_bit))
+	mask &= ((((W[43] ^ (W[42] >> 5)) & (1 << 1)) - (1 << 1)) | ^(DV_II_46_2_bit | DV_II_51_2_bit))
+	mask &= ((((W[42] ^ (W[41] >> 5)) & (1 << 1)) - (1 << 1)) | ^(DV_I_51_2_bit | DV_II_50_2_bit))
+	mask &= ((((W[41] ^ (W[40] >> 5)) & (1 << 1)) - (1 << 1)) | ^(DV_I_50_2_bit | DV_II_49_2_bit))
+	if (mask & (DV_I_52_0_bit | DV_II_51_0_bit)) != 0 {
+		mask &= ((((W[39] ^ (W[43] >> 25)) & (1 << 4)) - (1 << 4)) | ^(DV_I_52_0_bit | DV_II_51_0_bit))
+	}
+	if (mask & (DV_I_51_0_bit | DV_II_50_0_bit)) != 0 {
+		mask &= ((((W[38] ^ (W[42] >> 25)) & (1 << 4)) - (1 << 4)) | ^(DV_I_51_0_bit | DV_II_50_0_bit))
+	}
+	if (mask & (DV_I_48_2_bit | DV_I_51_2_bit)) != 0 {
+		mask &= ((0 - ((W[37] ^ (W[38] >> 5)) & (1 << 1))) | ^(DV_I_48_2_bit | DV_I_51_2_bit))
+	}
+	if (mask & (DV_I_50_0_bit | DV_II_49_0_bit)) != 0 {
+		mask &= ((((W[37] ^ (W[41] >> 25)) & (1 << 4)) - (1 << 4)) | ^(DV_I_50_0_bit | DV_II_49_0_bit))
+	}
+	if (mask & (DV_II_52_0_bit | DV_II_54_0_bit)) != 0 {
+		mask &= ((0 - ((W[36] ^ W[38]) & (1 << 4))) | ^(DV_II_52_0_bit | DV_II_54_0_bit))
+	}
+	mask &= ((0 - ((W[35] ^ (W[36] >> 5)) & (1 << 1))) | ^(DV_I_46_2_bit | DV_I_49_2_bit))
+	if (mask & (DV_I_51_0_bit | DV_II_47_0_bit)) != 0 {
+		mask &= ((((W[35] ^ (W[39] >> 25)) & (1 << 3)) - (1 << 3)) | ^(DV_I_51_0_bit | DV_II_47_0_bit))
+	}
+
+	if mask != 0 {
+		if (mask & DV_I_43_0_bit) != 0 {
+			if not((W[61]^(W[62]>>5))&(1<<1)) != 0 ||
+				not(not((W[59]^(W[63]>>25))&(1<<5))) != 0 ||
+				not((W[58]^(W[63]>>30))&(1<<0)) != 0 {
+				mask &= ^DV_I_43_0_bit
+			}
+		}
+		if (mask & DV_I_44_0_bit) != 0 {
+			if not((W[62]^(W[63]>>5))&(1<<1)) != 0 ||
+				not(not((W[60]^(W[64]>>25))&(1<<5))) != 0 ||
+				not((W[59]^(W[64]>>30))&(1<<0)) != 0 {
+				mask &= ^DV_I_44_0_bit
+			}
+		}
+		if (mask & DV_I_46_2_bit) != 0 {
+			mask &= ((^((W[40] ^ W[42]) >> 2)) | ^DV_I_46_2_bit)
+		}
+		if (mask & DV_I_47_2_bit) != 0 {
+			if not((W[62]^(W[63]>>5))&(1<<2)) != 0 ||
+				not(not((W[41]^W[43])&(1<<6))) != 0 {
+				mask &= ^DV_I_47_2_bit
+			}
+		}
+		if (mask & DV_I_48_2_bit) != 0 {
+			if not((W[63]^(W[64]>>5))&(1<<2)) != 0 ||
+				not(not((W[48]^(W[49]<<5))&(1<<6))) != 0 {
+				mask &= ^DV_I_48_2_bit
+			}
+		}
+		if (mask & DV_I_49_2_bit) != 0 {
+			if not(not((W[49]^(W[50]<<5))&(1<<6))) != 0 ||
+				not((W[42]^W[50])&(1<<1)) != 0 ||
+				not(not((W[39]^(W[40]<<5))&(1<<6))) != 0 ||
+				not((W[38]^W[40])&(1<<1)) != 0 {
+				mask &= ^DV_I_49_2_bit
+			}
+		}
+		if (mask & DV_I_50_0_bit) != 0 {
+			mask &= (((W[36] ^ W[37]) << 7) | ^DV_I_50_0_bit)
+		}
+		if (mask & DV_I_50_2_bit) != 0 {
+			mask &= (((W[43] ^ W[51]) << 11) | ^DV_I_50_2_bit)
+		}
+		if (mask & DV_I_51_0_bit) != 0 {
+			mask &= (((W[37] ^ W[38]) << 9) | ^DV_I_51_0_bit)
+		}
+		if (mask & DV_I_51_2_bit) != 0 {
+			if not(not((W[51]^(W[52]<<5))&(1<<6))) != 0 ||
+				not(not((W[49]^W[51])&(1<<6))) != 0 ||
+				not(not((W[37]^(W[37]>>5))&(1<<1))) != 0 ||
+				not(not((W[35]^(W[39]>>25))&(1<<5))) != 0 {
+				mask &= ^DV_I_51_2_bit
+			}
+		}
+		if (mask & DV_I_52_0_bit) != 0 {
+			mask &= (((W[38] ^ W[39]) << 11) | ^DV_I_52_0_bit)
+		}
+		if (mask & DV_II_46_2_bit) != 0 {
+			mask &= (((W[47] ^ W[51]) << 17) | ^DV_II_46_2_bit)
+		}
+		if (mask & DV_II_48_0_bit) != 0 {
+			if not(not((W[36]^(W[40]>>25))&(1<<3))) != 0 ||
+				not((W[35]^(W[40]<<2))&(1<<30)) != 0 {
+				mask &= ^DV_II_48_0_bit
+			}
+		}
+		if (mask & DV_II_49_0_bit) != 0 {
+			if not(not((W[37]^(W[41]>>25))&(1<<3))) != 0 ||
+				not((W[36]^(W[41]<<2))&(1<<30)) != 0 {
+				mask &= ^DV_II_49_0_bit
+			}
+		}
+		if (mask & DV_II_49_2_bit) != 0 {
+			if not(not((W[53]^(W[54]<<5))&(1<<6))) != 0 ||
+				not(not((W[51]^W[53])&(1<<6))) != 0 ||
+				not((W[50]^W[54])&(1<<1)) != 0 ||
+				not(not((W[45]^(W[46]<<5))&(1<<6))) != 0 ||
+				not(not((W[37]^(W[41]>>25))&(1<<5))) != 0 ||
+				not((W[36]^(W[41]>>30))&(1<<0)) != 0 {
+				mask &= ^DV_II_49_2_bit
+			}
+		}
+		if (mask & DV_II_50_0_bit) != 0 {
+			if not((W[55]^W[58])&(1<<29)) != 0 ||
+				not(not((W[38]^(W[42]>>25))&(1<<3))) != 0 ||
+				not((W[37]^(W[42]<<2))&(1<<30)) != 0 {
+				mask &= ^DV_II_50_0_bit
+			}
+		}
+		if (mask & DV_II_50_2_bit) != 0 {
+			if not(not((W[54]^(W[55]<<5))&(1<<6))) != 0 ||
+				not(not((W[52]^W[54])&(1<<6))) != 0 ||
+				not((W[51]^W[55])&(1<<1)) != 0 ||
+				not((W[45]^W[47])&(1<<1)) != 0 ||
+				not(not((W[38]^(W[42]>>25))&(1<<5))) != 0 ||
+				not((W[37]^(W[42]>>30))&(1<<0)) != 0 {
+				mask &= ^DV_II_50_2_bit
+			}
+		}
+		if (mask & DV_II_51_0_bit) != 0 {
+			if not(not((W[39]^(W[43]>>25))&(1<<3))) != 0 ||
+				not((W[38]^(W[43]<<2))&(1<<30)) != 0 {
+				mask &= ^DV_II_51_0_bit
+			}
+		}
+		if (mask & DV_II_51_2_bit) != 0 {
+			if not(not((W[55]^(W[56]<<5))&(1<<6))) != 0 ||
+				not(not((W[53]^W[55])&(1<<6))) != 0 ||
+				not((W[52]^W[56])&(1<<1)) != 0 ||
+				not((W[46]^W[48])&(1<<1)) != 0 ||
+				not(not((W[39]^(W[43]>>25))&(1<<5))) != 0 ||
+				not((W[38]^(W[43]>>30))&(1<<0)) != 0 {
+				mask &= ^DV_II_51_2_bit
+			}
+		}
+		if (mask & DV_II_52_0_bit) != 0 {
+			if not(not((W[59]^W[60])&(1<<29))) != 0 ||
+				not(not((W[40]^(W[44]>>25))&(1<<3))) != 0 ||
+				not(not((W[40]^(W[44]>>25))&(1<<4))) != 0 ||
+				not((W[39]^(W[44]<<2))&(1<<30)) != 0 {
+				mask &= ^DV_II_52_0_bit
+			}
+		}
+		if (mask & DV_II_53_0_bit) != 0 {
+			if not((W[58]^W[61])&(1<<29)) != 0 ||
+				not(not((W[57]^(W[61]>>25))&(1<<4))) != 0 ||
+				not(not((W[41]^(W[45]>>25))&(1<<3))) != 0 ||
+				not(not((W[41]^(W[45]>>25))&(1<<4))) != 0 {
+				mask &= ^DV_II_53_0_bit
+			}
+		}
+		if (mask & DV_II_54_0_bit) != 0 {
+			if not(not((W[58]^(W[62]>>25))&(1<<4))) != 0 ||
+				not(not((W[42]^(W[46]>>25))&(1<<3))) != 0 ||
+				not(not((W[42]^(W[46]>>25))&(1<<4))) != 0 {
+				mask &= ^DV_II_54_0_bit
+			}
+		}
+		if (mask & DV_II_55_0_bit) != 0 {
+			if not(not((W[59]^(W[63]>>25))&(1<<4))) != 0 ||
+				not(not((W[57]^(W[59]>>25))&(1<<4))) != 0 ||
+				not(not((W[43]^(W[47]>>25))&(1<<3))) != 0 ||
+				not(not((W[43]^(W[47]>>25))&(1<<4))) != 0 {
+				mask &= ^DV_II_55_0_bit
+			}
+		}
+		if (mask & DV_II_56_0_bit) != 0 {
+			if not(not((W[60]^(W[64]>>25))&(1<<4))) != 0 ||
+				not(not((W[44]^(W[48]>>25))&(1<<3))) != 0 ||
+				not(not((W[44]^(W[48]>>25))&(1<<4))) != 0 {
+				mask &= ^DV_II_56_0_bit
+			}
+		}
+	}
+
+	return mask, nil
+}
+
+func not(x uint32) uint32 {
+	if x == 0 {
+		return 1
+	}
+
+	return 0
+}
+
+func SHA1_dvs() []DvInfo {
+	return sha1_dvs
+}
--- a/vendor/github.com/pjbgf/sha1cd/ubc/const.go
+++ b/vendor/github.com/pjbgf/sha1cd/ubc/const.go
@@ -0,0 +1,624 @@
+// Based on the C implementation from Marc Stevens and Dan Shumow.
+// https://github.com/cr-marcstevens/sha1collisiondetection
+
+package ubc
+
+const (
+	CheckSize = 80
+
+	DV_I_43_0_bit  = (uint32)(1 << 0)
+	DV_I_44_0_bit  = (uint32)(1 << 1)
+	DV_I_45_0_bit  = (uint32)(1 << 2)
+	DV_I_46_0_bit  = (uint32)(1 << 3)
+	DV_I_46_2_bit  = (uint32)(1 << 4)
+	DV_I_47_0_bit  = (uint32)(1 << 5)
+	DV_I_47_2_bit  = (uint32)(1 << 6)
+	DV_I_48_0_bit  = (uint32)(1 << 7)
+	DV_I_48_2_bit  = (uint32)(1 << 8)
+	DV_I_49_0_bit  = (uint32)(1 << 9)
+	DV_I_49_2_bit  = (uint32)(1 << 10)
+	DV_I_50_0_bit  = (uint32)(1 << 11)
+	DV_I_50_2_bit  = (uint32)(1 << 12)
+	DV_I_51_0_bit  = (uint32)(1 << 13)
+	DV_I_51_2_bit  = (uint32)(1 << 14)
+	DV_I_52_0_bit  = (uint32)(1 << 15)
+	DV_II_45_0_bit = (uint32)(1 << 16)
+	DV_II_46_0_bit = (uint32)(1 << 17)
+	DV_II_46_2_bit = (uint32)(1 << 18)
+	DV_II_47_0_bit = (uint32)(1 << 19)
+	DV_II_48_0_bit = (uint32)(1 << 20)
+	DV_II_49_0_bit = (uint32)(1 << 21)
+	DV_II_49_2_bit = (uint32)(1 << 22)
+	DV_II_50_0_bit = (uint32)(1 << 23)
+	DV_II_50_2_bit = (uint32)(1 << 24)
+	DV_II_51_0_bit = (uint32)(1 << 25)
+	DV_II_51_2_bit = (uint32)(1 << 26)
+	DV_II_52_0_bit = (uint32)(1 << 27)
+	DV_II_53_0_bit = (uint32)(1 << 28)
+	DV_II_54_0_bit = (uint32)(1 << 29)
+	DV_II_55_0_bit = (uint32)(1 << 30)
+	DV_II_56_0_bit = (uint32)(1 << 31)
+)
+
+// sha1_dvs contains a list of SHA-1 Disturbance Vectors (DV) which defines the
+// unavoidable bit conditions when a collision attack is in progress.
+var sha1_dvs = []DvInfo{
+	{
+		DvType: 1, DvK: 43, DvB: 0, TestT: 58, MaskI: 0, MaskB: 0,
+		Dm: [CheckSize]uint32{
+			0x08000000, 0x9800000c, 0xd8000010, 0x08000010, 0xb8000010, 0x98000000, 0x60000000,
+			0x00000008, 0xc0000000, 0x90000014, 0x10000010, 0xb8000014, 0x28000000, 0x20000010,
+			0x48000000, 0x08000018, 0x60000000, 0x90000010, 0xf0000010, 0x90000008, 0xc0000000,
+			0x90000010, 0xf0000010, 0xb0000008, 0x40000000, 0x90000000, 0xf0000010, 0x90000018,
+			0x60000000, 0x90000010, 0x90000010, 0x90000000, 0x80000000, 0x00000010, 0xa0000000,
+			0x20000000, 0xa0000000, 0x20000010, 0x00000000, 0x20000010, 0x20000000, 0x00000010,
+			0x20000000, 0x00000010, 0xa0000000, 0x00000000, 0x20000000, 0x20000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000001, 0x00000020, 0x00000001, 0x40000002, 0x40000040,
+			0x40000002, 0x80000004, 0x80000080, 0x80000006, 0x00000049, 0x00000103, 0x80000009,
+			0x80000012, 0x80000202, 0x00000018, 0x00000164, 0x00000408, 0x800000e6, 0x8000004c,
+			0x00000803, 0x80000161, 0x80000599},
+	}, {
+		DvType: 1, DvK: 44, DvB: 0, TestT: 58, MaskI: 0, MaskB: 1,
+		Dm: [CheckSize]uint32{
+			0xb4000008, 0x08000000, 0x9800000c, 0xd8000010, 0x08000010, 0xb8000010, 0x98000000,
+			0x60000000, 0x00000008, 0xc0000000, 0x90000014, 0x10000010, 0xb8000014, 0x28000000,
+			0x20000010, 0x48000000, 0x08000018, 0x60000000, 0x90000010, 0xf0000010, 0x90000008,
+			0xc0000000, 0x90000010, 0xf0000010, 0xb0000008, 0x40000000, 0x90000000, 0xf0000010,
+			0x90000018, 0x60000000, 0x90000010, 0x90000010, 0x90000000, 0x80000000, 0x00000010,
+			0xa0000000, 0x20000000, 0xa0000000, 0x20000010, 0x00000000, 0x20000010, 0x20000000,
+			0x00000010, 0x20000000, 0x00000010, 0xa0000000, 0x00000000, 0x20000000, 0x20000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000020, 0x00000001, 0x40000002,
+			0x40000040, 0x40000002, 0x80000004, 0x80000080, 0x80000006, 0x00000049, 0x00000103,
+			0x80000009, 0x80000012, 0x80000202, 0x00000018, 0x00000164, 0x00000408, 0x800000e6,
+			0x8000004c, 0x00000803, 0x80000161},
+	},
+	{
+		DvType: 1, DvK: 45, DvB: 0, TestT: 58, MaskI: 0, MaskB: 2,
+		Dm: [CheckSize]uint32{
+			0xf4000014, 0xb4000008, 0x08000000, 0x9800000c, 0xd8000010, 0x08000010, 0xb8000010,
+			0x98000000, 0x60000000, 0x00000008, 0xc0000000, 0x90000014, 0x10000010, 0xb8000014,
+			0x28000000, 0x20000010, 0x48000000, 0x08000018, 0x60000000, 0x90000010, 0xf0000010,
+			0x90000008, 0xc0000000, 0x90000010, 0xf0000010, 0xb0000008, 0x40000000, 0x90000000,
+			0xf0000010, 0x90000018, 0x60000000, 0x90000010, 0x90000010, 0x90000000, 0x80000000,
+			0x00000010, 0xa0000000, 0x20000000, 0xa0000000, 0x20000010, 0x00000000, 0x20000010,
+			0x20000000, 0x00000010, 0x20000000, 0x00000010, 0xa0000000, 0x00000000, 0x20000000,
+			0x20000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000020, 0x00000001,
+			0x40000002, 0x40000040, 0x40000002, 0x80000004, 0x80000080, 0x80000006, 0x00000049,
+			0x00000103, 0x80000009, 0x80000012, 0x80000202, 0x00000018, 0x00000164, 0x00000408,
+			0x800000e6, 0x8000004c, 0x00000803},
+	},
+	{
+		DvType: 1, DvK: 46, DvB: 0, TestT: 58, MaskI: 0, MaskB: 3,
+		Dm: [CheckSize]uint32{
+			0x2c000010, 0xf4000014, 0xb4000008, 0x08000000, 0x9800000c, 0xd8000010, 0x08000010,
+			0xb8000010, 0x98000000, 0x60000000, 0x00000008, 0xc0000000, 0x90000014, 0x10000010,
+			0xb8000014, 0x28000000, 0x20000010, 0x48000000, 0x08000018, 0x60000000, 0x90000010,
+			0xf0000010, 0x90000008, 0xc0000000, 0x90000010, 0xf0000010, 0xb0000008, 0x40000000,
+			0x90000000, 0xf0000010, 0x90000018, 0x60000000, 0x90000010, 0x90000010, 0x90000000,
+			0x80000000, 0x00000010, 0xa0000000, 0x20000000, 0xa0000000, 0x20000010, 0x00000000,
+			0x20000010, 0x20000000, 0x00000010, 0x20000000, 0x00000010, 0xa0000000, 0x00000000,
+			0x20000000, 0x20000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000020,
+			0x00000001, 0x40000002, 0x40000040, 0x40000002, 0x80000004, 0x80000080, 0x80000006,
+			0x00000049, 0x00000103, 0x80000009, 0x80000012, 0x80000202, 0x00000018, 0x00000164,
+			0x00000408, 0x800000e6, 0x8000004c},
+	},
+	{
+		DvType: 1, DvK: 46, DvB: 2, TestT: 58, MaskI: 0, MaskB: 4,
+		Dm: [CheckSize]uint32{
+			0xb0000040, 0xd0000053, 0xd0000022, 0x20000000, 0x60000032, 0x60000043,
+			0x20000040, 0xe0000042, 0x60000002, 0x80000001, 0x00000020, 0x00000003,
+			0x40000052, 0x40000040, 0xe0000052, 0xa0000000, 0x80000040, 0x20000001,
+			0x20000060, 0x80000001, 0x40000042, 0xc0000043, 0x40000022, 0x00000003,
+			0x40000042, 0xc0000043, 0xc0000022, 0x00000001, 0x40000002, 0xc0000043,
+			0x40000062, 0x80000001, 0x40000042, 0x40000042, 0x40000002, 0x00000002,
+			0x00000040, 0x80000002, 0x80000000, 0x80000002, 0x80000040, 0x00000000,
+			0x80000040, 0x80000000, 0x00000040, 0x80000000, 0x00000040, 0x80000002,
+			0x00000000, 0x80000000, 0x80000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000004, 0x00000080, 0x00000004, 0x00000009, 0x00000101,
+			0x00000009, 0x00000012, 0x00000202, 0x0000001a, 0x00000124, 0x0000040c,
+			0x00000026, 0x0000004a, 0x0000080a, 0x00000060, 0x00000590, 0x00001020,
+			0x0000039a, 0x00000132},
+	},
+	{
+		DvType: 1, DvK: 47, DvB: 0, TestT: 58, MaskI: 0, MaskB: 5,
+		Dm: [CheckSize]uint32{
+			0xc8000010, 0x2c000010, 0xf4000014, 0xb4000008, 0x08000000, 0x9800000c,
+			0xd8000010, 0x08000010, 0xb8000010, 0x98000000, 0x60000000, 0x00000008,
+			0xc0000000, 0x90000014, 0x10000010, 0xb8000014, 0x28000000, 0x20000010,
+			0x48000000, 0x08000018, 0x60000000, 0x90000010, 0xf0000010, 0x90000008,
+			0xc0000000, 0x90000010, 0xf0000010, 0xb0000008, 0x40000000, 0x90000000,
+			0xf0000010, 0x90000018, 0x60000000, 0x90000010, 0x90000010, 0x90000000,
+			0x80000000, 0x00000010, 0xa0000000, 0x20000000, 0xa0000000, 0x20000010,
+			0x00000000, 0x20000010, 0x20000000, 0x00000010, 0x20000000, 0x00000010,
+			0xa0000000, 0x00000000, 0x20000000, 0x20000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000001, 0x00000020, 0x00000001, 0x40000002,
+			0x40000040, 0x40000002, 0x80000004, 0x80000080, 0x80000006, 0x00000049,
+			0x00000103, 0x80000009, 0x80000012, 0x80000202, 0x00000018, 0x00000164,
+			0x00000408, 0x800000e6},
+	},
+	{
+		DvType: 1, DvK: 47, DvB: 2, TestT: 58, MaskI: 0, MaskB: 6,
+		Dm: [CheckSize]uint32{
+			0x20000043, 0xb0000040, 0xd0000053, 0xd0000022, 0x20000000, 0x60000032,
+			0x60000043, 0x20000040, 0xe0000042, 0x60000002, 0x80000001, 0x00000020,
+			0x00000003, 0x40000052, 0x40000040, 0xe0000052, 0xa0000000, 0x80000040,
+			0x20000001, 0x20000060, 0x80000001, 0x40000042, 0xc0000043, 0x40000022,
+			0x00000003, 0x40000042, 0xc0000043, 0xc0000022, 0x00000001, 0x40000002,
+			0xc0000043, 0x40000062, 0x80000001, 0x40000042, 0x40000042, 0x40000002,
+			0x00000002, 0x00000040, 0x80000002, 0x80000000, 0x80000002, 0x80000040,
+			0x00000000, 0x80000040, 0x80000000, 0x00000040, 0x80000000, 0x00000040,
+			0x80000002, 0x00000000, 0x80000000, 0x80000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000004, 0x00000080, 0x00000004, 0x00000009,
+			0x00000101, 0x00000009, 0x00000012, 0x00000202, 0x0000001a, 0x00000124,
+			0x0000040c, 0x00000026, 0x0000004a, 0x0000080a, 0x00000060, 0x00000590,
+			0x00001020, 0x0000039a,
+		},
+	},
+	{
+		DvType: 1, DvK: 48, DvB: 0, TestT: 58, MaskI: 0, MaskB: 7,
+		Dm: [CheckSize]uint32{
+			0xb800000a, 0xc8000010, 0x2c000010, 0xf4000014, 0xb4000008, 0x08000000,
+			0x9800000c, 0xd8000010, 0x08000010, 0xb8000010, 0x98000000, 0x60000000,
+			0x00000008, 0xc0000000, 0x90000014, 0x10000010, 0xb8000014, 0x28000000,
+			0x20000010, 0x48000000, 0x08000018, 0x60000000, 0x90000010, 0xf0000010,
+			0x90000008, 0xc0000000, 0x90000010, 0xf0000010, 0xb0000008, 0x40000000,
+			0x90000000, 0xf0000010, 0x90000018, 0x60000000, 0x90000010, 0x90000010,
+			0x90000000, 0x80000000, 0x00000010, 0xa0000000, 0x20000000, 0xa0000000,
+			0x20000010, 0x00000000, 0x20000010, 0x20000000, 0x00000010, 0x20000000,
+			0x00000010, 0xa0000000, 0x00000000, 0x20000000, 0x20000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000020, 0x00000001,
+			0x40000002, 0x40000040, 0x40000002, 0x80000004, 0x80000080, 0x80000006,
+			0x00000049, 0x00000103, 0x80000009, 0x80000012, 0x80000202, 0x00000018,
+			0x00000164, 0x00000408,
+		},
+	},
+	{
+		DvType: 1, DvK: 48, DvB: 2, TestT: 58, MaskI: 0, MaskB: 8,
+		Dm: [CheckSize]uint32{
+			0xe000002a, 0x20000043, 0xb0000040, 0xd0000053, 0xd0000022, 0x20000000,
+			0x60000032, 0x60000043, 0x20000040, 0xe0000042, 0x60000002, 0x80000001,
+			0x00000020, 0x00000003, 0x40000052, 0x40000040, 0xe0000052, 0xa0000000,
+			0x80000040, 0x20000001, 0x20000060, 0x80000001, 0x40000042, 0xc0000043,
+			0x40000022, 0x00000003, 0x40000042, 0xc0000043, 0xc0000022, 0x00000001,
+			0x40000002, 0xc0000043, 0x40000062, 0x80000001, 0x40000042, 0x40000042,
+			0x40000002, 0x00000002, 0x00000040, 0x80000002, 0x80000000, 0x80000002,
+			0x80000040, 0x00000000, 0x80000040, 0x80000000, 0x00000040, 0x80000000,
+			0x00000040, 0x80000002, 0x00000000, 0x80000000, 0x80000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000004, 0x00000080, 0x00000004,
+			0x00000009, 0x00000101, 0x00000009, 0x00000012, 0x00000202, 0x0000001a,
+			0x00000124, 0x0000040c, 0x00000026, 0x0000004a, 0x0000080a, 0x00000060,
+			0x00000590, 0x00001020},
+	},
+	{
+		DvType: 1, DvK: 49, DvB: 0, TestT: 58, MaskI: 0, MaskB: 9,
+		Dm: [CheckSize]uint32{
+			0x18000000, 0xb800000a, 0xc8000010, 0x2c000010, 0xf4000014, 0xb4000008,
+			0x08000000, 0x9800000c, 0xd8000010, 0x08000010, 0xb8000010, 0x98000000,
+			0x60000000, 0x00000008, 0xc0000000, 0x90000014, 0x10000010, 0xb8000014,
+			0x28000000, 0x20000010, 0x48000000, 0x08000018, 0x60000000, 0x90000010,
+			0xf0000010, 0x90000008, 0xc0000000, 0x90000010, 0xf0000010, 0xb0000008,
+			0x40000000, 0x90000000, 0xf0000010, 0x90000018, 0x60000000, 0x90000010,
+			0x90000010, 0x90000000, 0x80000000, 0x00000010, 0xa0000000, 0x20000000,
+			0xa0000000, 0x20000010, 0x00000000, 0x20000010, 0x20000000, 0x00000010,
+			0x20000000, 0x00000010, 0xa0000000, 0x00000000, 0x20000000, 0x20000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000020,
+			0x00000001, 0x40000002, 0x40000040, 0x40000002, 0x80000004, 0x80000080,
+			0x80000006, 0x00000049, 0x00000103, 0x80000009, 0x80000012, 0x80000202,
+			0x00000018, 0x00000164},
+	},
+	{
+		DvType: 1, DvK: 49, DvB: 2, TestT: 58, MaskI: 0, MaskB: 10,
+		Dm: [CheckSize]uint32{
+			0x60000000, 0xe000002a, 0x20000043, 0xb0000040, 0xd0000053, 0xd0000022,
+			0x20000000, 0x60000032, 0x60000043, 0x20000040, 0xe0000042, 0x60000002,
+			0x80000001, 0x00000020, 0x00000003, 0x40000052, 0x40000040, 0xe0000052,
+			0xa0000000, 0x80000040, 0x20000001, 0x20000060, 0x80000001, 0x40000042,
+			0xc0000043, 0x40000022, 0x00000003, 0x40000042, 0xc0000043, 0xc0000022,
+			0x00000001, 0x40000002, 0xc0000043, 0x40000062, 0x80000001, 0x40000042,
+			0x40000042, 0x40000002, 0x00000002, 0x00000040, 0x80000002, 0x80000000,
+			0x80000002, 0x80000040, 0x00000000, 0x80000040, 0x80000000, 0x00000040,
+			0x80000000, 0x00000040, 0x80000002, 0x00000000, 0x80000000, 0x80000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000004, 0x00000080,
+			0x00000004, 0x00000009, 0x00000101, 0x00000009, 0x00000012, 0x00000202,
+			0x0000001a, 0x00000124, 0x0000040c, 0x00000026, 0x0000004a, 0x0000080a,
+			0x00000060, 0x00000590},
+	},
+	{
+		DvType: 1, DvK: 50, DvB: 0, TestT: 65, MaskI: 0, MaskB: 11,
+		Dm: [CheckSize]uint32{
+			0x0800000c, 0x18000000, 0xb800000a, 0xc8000010, 0x2c000010, 0xf4000014,
+			0xb4000008, 0x08000000, 0x9800000c, 0xd8000010, 0x08000010, 0xb8000010,
+			0x98000000, 0x60000000, 0x00000008, 0xc0000000, 0x90000014, 0x10000010,
+			0xb8000014, 0x28000000, 0x20000010, 0x48000000, 0x08000018, 0x60000000,
+			0x90000010, 0xf0000010, 0x90000008, 0xc0000000, 0x90000010, 0xf0000010,
+			0xb0000008, 0x40000000, 0x90000000, 0xf0000010, 0x90000018, 0x60000000,
+			0x90000010, 0x90000010, 0x90000000, 0x80000000, 0x00000010, 0xa0000000,
+			0x20000000, 0xa0000000, 0x20000010, 0x00000000, 0x20000010, 0x20000000,
+			0x00000010, 0x20000000, 0x00000010, 0xa0000000, 0x00000000, 0x20000000,
+			0x20000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000001,
+			0x00000020, 0x00000001, 0x40000002, 0x40000040, 0x40000002, 0x80000004,
+			0x80000080, 0x80000006, 0x00000049, 0x00000103, 0x80000009, 0x80000012,
+			0x80000202, 0x00000018,
+		},
+	},
+	{
+		DvType: 1, DvK: 50, DvB: 2, TestT: 65, MaskI: 0, MaskB: 12,
+		Dm: [CheckSize]uint32{
+			0x20000030, 0x60000000, 0xe000002a, 0x20000043, 0xb0000040, 0xd0000053,
+			0xd0000022, 0x20000000, 0x60000032, 0x60000043, 0x20000040, 0xe0000042,
+			0x60000002, 0x80000001, 0x00000020, 0x00000003, 0x40000052, 0x40000040,
+			0xe0000052, 0xa0000000, 0x80000040, 0x20000001, 0x20000060, 0x80000001,
+			0x40000042, 0xc0000043, 0x40000022, 0x00000003, 0x40000042, 0xc0000043,
+			0xc0000022, 0x00000001, 0x40000002, 0xc0000043, 0x40000062, 0x80000001,
+			0x40000042, 0x40000042, 0x40000002, 0x00000002, 0x00000040, 0x80000002,
+			0x80000000, 0x80000002, 0x80000040, 0x00000000, 0x80000040, 0x80000000,
+			0x00000040, 0x80000000, 0x00000040, 0x80000002, 0x00000000, 0x80000000,
+			0x80000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000004,
+			0x00000080, 0x00000004, 0x00000009, 0x00000101, 0x00000009, 0x00000012,
+			0x00000202, 0x0000001a, 0x00000124, 0x0000040c, 0x00000026, 0x0000004a,
+			0x0000080a, 0x00000060},
+	},
+	{
+		DvType: 1, DvK: 51, DvB: 0, TestT: 65, MaskI: 0, MaskB: 13,
+		Dm: [CheckSize]uint32{
+			0xe8000000, 0x0800000c, 0x18000000, 0xb800000a, 0xc8000010, 0x2c000010,
+			0xf4000014, 0xb4000008, 0x08000000, 0x9800000c, 0xd8000010, 0x08000010,
+			0xb8000010, 0x98000000, 0x60000000, 0x00000008, 0xc0000000, 0x90000014,
+			0x10000010, 0xb8000014, 0x28000000, 0x20000010, 0x48000000, 0x08000018,
+			0x60000000, 0x90000010, 0xf0000010, 0x90000008, 0xc0000000, 0x90000010,
+			0xf0000010, 0xb0000008, 0x40000000, 0x90000000, 0xf0000010, 0x90000018,
+			0x60000000, 0x90000010, 0x90000010, 0x90000000, 0x80000000, 0x00000010,
+			0xa0000000, 0x20000000, 0xa0000000, 0x20000010, 0x00000000, 0x20000010,
+			0x20000000, 0x00000010, 0x20000000, 0x00000010, 0xa0000000, 0x00000000,
+			0x20000000, 0x20000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000001, 0x00000020, 0x00000001, 0x40000002, 0x40000040, 0x40000002,
+			0x80000004, 0x80000080, 0x80000006, 0x00000049, 0x00000103, 0x80000009,
+			0x80000012, 0x80000202},
+	},
+	{
+		DvType: 1, DvK: 51, DvB: 2, TestT: 65, MaskI: 0, MaskB: 14,
+		Dm: [CheckSize]uint32{
+			0xa0000003, 0x20000030, 0x60000000, 0xe000002a, 0x20000043, 0xb0000040,
+			0xd0000053, 0xd0000022, 0x20000000, 0x60000032, 0x60000043, 0x20000040,
+			0xe0000042, 0x60000002, 0x80000001, 0x00000020, 0x00000003, 0x40000052,
+			0x40000040, 0xe0000052, 0xa0000000, 0x80000040, 0x20000001, 0x20000060,
+			0x80000001, 0x40000042, 0xc0000043, 0x40000022, 0x00000003, 0x40000042,
+			0xc0000043, 0xc0000022, 0x00000001, 0x40000002, 0xc0000043, 0x40000062,
+			0x80000001, 0x40000042, 0x40000042, 0x40000002, 0x00000002, 0x00000040,
+			0x80000002, 0x80000000, 0x80000002, 0x80000040, 0x00000000, 0x80000040,
+			0x80000000, 0x00000040, 0x80000000, 0x00000040, 0x80000002, 0x00000000,
+			0x80000000, 0x80000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000004, 0x00000080, 0x00000004, 0x00000009, 0x00000101, 0x00000009,
+			0x00000012, 0x00000202, 0x0000001a, 0x00000124, 0x0000040c, 0x00000026,
+			0x0000004a, 0x0000080a},
+	},
+	{
+		DvType: 1, DvK: 52, DvB: 0, TestT: 65, MaskI: 0, MaskB: 15,
+		Dm: [CheckSize]uint32{
+			0x04000010, 0xe8000000, 0x0800000c, 0x18000000, 0xb800000a, 0xc8000010,
+			0x2c000010, 0xf4000014, 0xb4000008, 0x08000000, 0x9800000c, 0xd8000010,
+			0x08000010, 0xb8000010, 0x98000000, 0x60000000, 0x00000008, 0xc0000000,
+			0x90000014, 0x10000010, 0xb8000014, 0x28000000, 0x20000010, 0x48000000,
+			0x08000018, 0x60000000, 0x90000010, 0xf0000010, 0x90000008, 0xc0000000,
+			0x90000010, 0xf0000010, 0xb0000008, 0x40000000, 0x90000000, 0xf0000010,
+			0x90000018, 0x60000000, 0x90000010, 0x90000010, 0x90000000, 0x80000000,
+			0x00000010, 0xa0000000, 0x20000000, 0xa0000000, 0x20000010, 0x00000000,
+			0x20000010, 0x20000000, 0x00000010, 0x20000000, 0x00000010, 0xa0000000,
+			0x00000000, 0x20000000, 0x20000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000001, 0x00000020, 0x00000001, 0x40000002, 0x40000040,
+			0x40000002, 0x80000004, 0x80000080, 0x80000006, 0x00000049, 0x00000103,
+			0x80000009, 0x80000012},
+	},
+	{
+		DvType: 2, DvK: 45, DvB: 0, TestT: 58, MaskI: 0, MaskB: 16,
+		Dm: [CheckSize]uint32{
+			0xec000014, 0x0c000002, 0xc0000010, 0xb400001c, 0x2c000004, 0xbc000018,
+			0xb0000010, 0x0000000c, 0xb8000010, 0x08000018, 0x78000010, 0x08000014,
+			0x70000010, 0xb800001c, 0xe8000000, 0xb0000004, 0x58000010, 0xb000000c,
+			0x48000000, 0xb0000000, 0xb8000010, 0x98000010, 0xa0000000, 0x00000000,
+			0x00000000, 0x20000000, 0x80000000, 0x00000010, 0x00000000, 0x20000010,
+			0x20000000, 0x00000010, 0x60000000, 0x00000018, 0xe0000000, 0x90000000,
+			0x30000010, 0xb0000000, 0x20000000, 0x20000000, 0xa0000000, 0x00000010,
+			0x80000000, 0x20000000, 0x20000000, 0x20000000, 0x80000000, 0x00000010,
+			0x00000000, 0x20000010, 0xa0000000, 0x00000000, 0x20000000, 0x20000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000001, 0x00000020, 0x00000001, 0x40000002, 0x40000041, 0x40000022,
+			0x80000005, 0xc0000082, 0xc0000046, 0x4000004b, 0x80000107, 0x00000089,
+			0x00000014, 0x8000024b, 0x0000011b, 0x8000016d, 0x8000041a, 0x000002e4,
+			0x80000054, 0x00000967},
+	},
+	{
+		DvType: 2, DvK: 46, DvB: 0, TestT: 58, MaskI: 0, MaskB: 17,
+		Dm: [CheckSize]uint32{
+			0x2400001c, 0xec000014, 0x0c000002, 0xc0000010, 0xb400001c, 0x2c000004,
+			0xbc000018, 0xb0000010, 0x0000000c, 0xb8000010, 0x08000018, 0x78000010,
+			0x08000014, 0x70000010, 0xb800001c, 0xe8000000, 0xb0000004, 0x58000010,
+			0xb000000c, 0x48000000, 0xb0000000, 0xb8000010, 0x98000010, 0xa0000000,
+			0x00000000, 0x00000000, 0x20000000, 0x80000000, 0x00000010, 0x00000000,
+			0x20000010, 0x20000000, 0x00000010, 0x60000000, 0x00000018, 0xe0000000,
+			0x90000000, 0x30000010, 0xb0000000, 0x20000000, 0x20000000, 0xa0000000,
+			0x00000010, 0x80000000, 0x20000000, 0x20000000, 0x20000000, 0x80000000,
+			0x00000010, 0x00000000, 0x20000010, 0xa0000000, 0x00000000, 0x20000000,
+			0x20000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000001, 0x00000020, 0x00000001, 0x40000002, 0x40000041,
+			0x40000022, 0x80000005, 0xc0000082, 0xc0000046, 0x4000004b, 0x80000107,
+			0x00000089, 0x00000014, 0x8000024b, 0x0000011b, 0x8000016d, 0x8000041a,
+			0x000002e4, 0x80000054},
+	},
+	{
+		DvType: 2, DvK: 46, DvB: 2, TestT: 58, MaskI: 0, MaskB: 18,
+		Dm: [CheckSize]uint32{
+			0x90000070, 0xb0000053, 0x30000008, 0x00000043, 0xd0000072, 0xb0000010,
+			0xf0000062, 0xc0000042, 0x00000030, 0xe0000042, 0x20000060, 0xe0000041,
+			0x20000050, 0xc0000041, 0xe0000072, 0xa0000003, 0xc0000012, 0x60000041,
+			0xc0000032, 0x20000001, 0xc0000002, 0xe0000042, 0x60000042, 0x80000002,
+			0x00000000, 0x00000000, 0x80000000, 0x00000002, 0x00000040, 0x00000000,
+			0x80000040, 0x80000000, 0x00000040, 0x80000001, 0x00000060, 0x80000003,
+			0x40000002, 0xc0000040, 0xc0000002, 0x80000000, 0x80000000, 0x80000002,
+			0x00000040, 0x00000002, 0x80000000, 0x80000000, 0x80000000, 0x00000002,
+			0x00000040, 0x00000000, 0x80000040, 0x80000002, 0x00000000, 0x80000000,
+			0x80000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000004, 0x00000080, 0x00000004, 0x00000009, 0x00000105,
+			0x00000089, 0x00000016, 0x0000020b, 0x0000011b, 0x0000012d, 0x0000041e,
+			0x00000224, 0x00000050, 0x0000092e, 0x0000046c, 0x000005b6, 0x0000106a,
+			0x00000b90, 0x00000152},
+	},
+	{
+		DvType: 2, DvK: 47, DvB: 0, TestT: 58, MaskI: 0, MaskB: 19,
+		Dm: [CheckSize]uint32{
+			0x20000010, 0x2400001c, 0xec000014, 0x0c000002, 0xc0000010, 0xb400001c,
+			0x2c000004, 0xbc000018, 0xb0000010, 0x0000000c, 0xb8000010, 0x08000018,
+			0x78000010, 0x08000014, 0x70000010, 0xb800001c, 0xe8000000, 0xb0000004,
+			0x58000010, 0xb000000c, 0x48000000, 0xb0000000, 0xb8000010, 0x98000010,
+			0xa0000000, 0x00000000, 0x00000000, 0x20000000, 0x80000000, 0x00000010,
+			0x00000000, 0x20000010, 0x20000000, 0x00000010, 0x60000000, 0x00000018,
+			0xe0000000, 0x90000000, 0x30000010, 0xb0000000, 0x20000000, 0x20000000,
+			0xa0000000, 0x00000010, 0x80000000, 0x20000000, 0x20000000, 0x20000000,
+			0x80000000, 0x00000010, 0x00000000, 0x20000010, 0xa0000000, 0x00000000,
+			0x20000000, 0x20000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000001, 0x00000020, 0x00000001, 0x40000002,
+			0x40000041, 0x40000022, 0x80000005, 0xc0000082, 0xc0000046, 0x4000004b,
+			0x80000107, 0x00000089, 0x00000014, 0x8000024b, 0x0000011b, 0x8000016d,
+			0x8000041a, 0x000002e4},
+	},
+	{
+		DvType: 2, DvK: 48, DvB: 0, TestT: 58, MaskI: 0, MaskB: 20,
+		Dm: [CheckSize]uint32{
+			0xbc00001a, 0x20000010, 0x2400001c, 0xec000014, 0x0c000002, 0xc0000010,
+			0xb400001c, 0x2c000004, 0xbc000018, 0xb0000010, 0x0000000c, 0xb8000010,
+			0x08000018, 0x78000010, 0x08000014, 0x70000010, 0xb800001c, 0xe8000000,
+			0xb0000004, 0x58000010, 0xb000000c, 0x48000000, 0xb0000000, 0xb8000010,
+			0x98000010, 0xa0000000, 0x00000000, 0x00000000, 0x20000000, 0x80000000,
+			0x00000010, 0x00000000, 0x20000010, 0x20000000, 0x00000010, 0x60000000,
+			0x00000018, 0xe0000000, 0x90000000, 0x30000010, 0xb0000000, 0x20000000,
+			0x20000000, 0xa0000000, 0x00000010, 0x80000000, 0x20000000, 0x20000000,
+			0x20000000, 0x80000000, 0x00000010, 0x00000000, 0x20000010, 0xa0000000,
+			0x00000000, 0x20000000, 0x20000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000020, 0x00000001,
+			0x40000002, 0x40000041, 0x40000022, 0x80000005, 0xc0000082, 0xc0000046,
+			0x4000004b, 0x80000107, 0x00000089, 0x00000014, 0x8000024b, 0x0000011b,
+			0x8000016d, 0x8000041a},
+	},
+	{
+		DvType: 2, DvK: 49, DvB: 0, TestT: 58, MaskI: 0, MaskB: 21,
+		Dm: [CheckSize]uint32{
+			0x3c000004, 0xbc00001a, 0x20000010, 0x2400001c, 0xec000014, 0x0c000002,
+			0xc0000010, 0xb400001c, 0x2c000004, 0xbc000018, 0xb0000010, 0x0000000c,
+			0xb8000010, 0x08000018, 0x78000010, 0x08000014, 0x70000010, 0xb800001c,
+			0xe8000000, 0xb0000004, 0x58000010, 0xb000000c, 0x48000000, 0xb0000000,
+			0xb8000010, 0x98000010, 0xa0000000, 0x00000000, 0x00000000, 0x20000000,
+			0x80000000, 0x00000010, 0x00000000, 0x20000010, 0x20000000, 0x00000010,
+			0x60000000, 0x00000018, 0xe0000000, 0x90000000, 0x30000010, 0xb0000000,
+			0x20000000, 0x20000000, 0xa0000000, 0x00000010, 0x80000000, 0x20000000,
+			0x20000000, 0x20000000, 0x80000000, 0x00000010, 0x00000000, 0x20000010,
+			0xa0000000, 0x00000000, 0x20000000, 0x20000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000020,
+			0x00000001, 0x40000002, 0x40000041, 0x40000022, 0x80000005, 0xc0000082,
+			0xc0000046, 0x4000004b, 0x80000107, 0x00000089, 0x00000014, 0x8000024b,
+			0x0000011b, 0x8000016d},
+	},
+	{
+		DvType: 2, DvK: 49, DvB: 2, TestT: 58, MaskI: 0, MaskB: 22,
+		Dm: [CheckSize]uint32{
+			0xf0000010, 0xf000006a, 0x80000040, 0x90000070, 0xb0000053, 0x30000008,
+			0x00000043, 0xd0000072, 0xb0000010, 0xf0000062, 0xc0000042, 0x00000030,
+			0xe0000042, 0x20000060, 0xe0000041, 0x20000050, 0xc0000041, 0xe0000072,
+			0xa0000003, 0xc0000012, 0x60000041, 0xc0000032, 0x20000001, 0xc0000002,
+			0xe0000042, 0x60000042, 0x80000002, 0x00000000, 0x00000000, 0x80000000,
+			0x00000002, 0x00000040, 0x00000000, 0x80000040, 0x80000000, 0x00000040,
+			0x80000001, 0x00000060, 0x80000003, 0x40000002, 0xc0000040, 0xc0000002,
+			0x80000000, 0x80000000, 0x80000002, 0x00000040, 0x00000002, 0x80000000,
+			0x80000000, 0x80000000, 0x00000002, 0x00000040, 0x00000000, 0x80000040,
+			0x80000002, 0x00000000, 0x80000000, 0x80000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000004, 0x00000080,
+			0x00000004, 0x00000009, 0x00000105, 0x00000089, 0x00000016, 0x0000020b,
+			0x0000011b, 0x0000012d, 0x0000041e, 0x00000224, 0x00000050, 0x0000092e,
+			0x0000046c, 0x000005b6},
+	},
+	{
+		DvType: 2, DvK: 50, DvB: 0, TestT: 65, MaskI: 0, MaskB: 23,
+		Dm: [CheckSize]uint32{
+			0xb400001c, 0x3c000004, 0xbc00001a, 0x20000010, 0x2400001c, 0xec000014,
+			0x0c000002, 0xc0000010, 0xb400001c, 0x2c000004, 0xbc000018, 0xb0000010,
+			0x0000000c, 0xb8000010, 0x08000018, 0x78000010, 0x08000014, 0x70000010,
+			0xb800001c, 0xe8000000, 0xb0000004, 0x58000010, 0xb000000c, 0x48000000,
+			0xb0000000, 0xb8000010, 0x98000010, 0xa0000000, 0x00000000, 0x00000000,
+			0x20000000, 0x80000000, 0x00000010, 0x00000000, 0x20000010, 0x20000000,
+			0x00000010, 0x60000000, 0x00000018, 0xe0000000, 0x90000000, 0x30000010,
+			0xb0000000, 0x20000000, 0x20000000, 0xa0000000, 0x00000010, 0x80000000,
+			0x20000000, 0x20000000, 0x20000000, 0x80000000, 0x00000010, 0x00000000,
+			0x20000010, 0xa0000000, 0x00000000, 0x20000000, 0x20000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000001,
+			0x00000020, 0x00000001, 0x40000002, 0x40000041, 0x40000022, 0x80000005,
+			0xc0000082, 0xc0000046, 0x4000004b, 0x80000107, 0x00000089, 0x00000014,
+			0x8000024b, 0x0000011b},
+	},
+	{
+		DvType: 2, DvK: 50, DvB: 2, TestT: 65, MaskI: 0, MaskB: 24,
+		Dm: [CheckSize]uint32{
+			0xd0000072, 0xf0000010, 0xf000006a, 0x80000040, 0x90000070, 0xb0000053,
+			0x30000008, 0x00000043, 0xd0000072, 0xb0000010, 0xf0000062, 0xc0000042,
+			0x00000030, 0xe0000042, 0x20000060, 0xe0000041, 0x20000050, 0xc0000041,
+			0xe0000072, 0xa0000003, 0xc0000012, 0x60000041, 0xc0000032, 0x20000001,
+			0xc0000002, 0xe0000042, 0x60000042, 0x80000002, 0x00000000, 0x00000000,
+			0x80000000, 0x00000002, 0x00000040, 0x00000000, 0x80000040, 0x80000000,
+			0x00000040, 0x80000001, 0x00000060, 0x80000003, 0x40000002, 0xc0000040,
+			0xc0000002, 0x80000000, 0x80000000, 0x80000002, 0x00000040, 0x00000002,
+			0x80000000, 0x80000000, 0x80000000, 0x00000002, 0x00000040, 0x00000000,
+			0x80000040, 0x80000002, 0x00000000, 0x80000000, 0x80000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000004,
+			0x00000080, 0x00000004, 0x00000009, 0x00000105, 0x00000089, 0x00000016,
+			0x0000020b, 0x0000011b, 0x0000012d, 0x0000041e, 0x00000224, 0x00000050,
+			0x0000092e, 0x0000046c},
+	},
+	{
+		DvType: 2, DvK: 51, DvB: 0, TestT: 65, MaskI: 0, MaskB: 25,
+		Dm: [CheckSize]uint32{
+			0xc0000010, 0xb400001c, 0x3c000004, 0xbc00001a, 0x20000010, 0x2400001c,
+			0xec000014, 0x0c000002, 0xc0000010, 0xb400001c, 0x2c000004, 0xbc000018,
+			0xb0000010, 0x0000000c, 0xb8000010, 0x08000018, 0x78000010, 0x08000014,
+			0x70000010, 0xb800001c, 0xe8000000, 0xb0000004, 0x58000010, 0xb000000c,
+			0x48000000, 0xb0000000, 0xb8000010, 0x98000010, 0xa0000000, 0x00000000,
+			0x00000000, 0x20000000, 0x80000000, 0x00000010, 0x00000000, 0x20000010,
+			0x20000000, 0x00000010, 0x60000000, 0x00000018, 0xe0000000, 0x90000000,
+			0x30000010, 0xb0000000, 0x20000000, 0x20000000, 0xa0000000, 0x00000010,
+			0x80000000, 0x20000000, 0x20000000, 0x20000000, 0x80000000, 0x00000010,
+			0x00000000, 0x20000010, 0xa0000000, 0x00000000, 0x20000000, 0x20000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000001, 0x00000020, 0x00000001, 0x40000002, 0x40000041, 0x40000022,
+			0x80000005, 0xc0000082, 0xc0000046, 0x4000004b, 0x80000107, 0x00000089,
+			0x00000014, 0x8000024b},
+	},
+	{
+		DvType: 2, DvK: 51, DvB: 2, TestT: 65, MaskI: 0, MaskB: 26,
+		Dm: [CheckSize]uint32{
+			0x00000043, 0xd0000072, 0xf0000010, 0xf000006a, 0x80000040, 0x90000070,
+			0xb0000053, 0x30000008, 0x00000043, 0xd0000072, 0xb0000010, 0xf0000062,
+			0xc0000042, 0x00000030, 0xe0000042, 0x20000060, 0xe0000041, 0x20000050,
+			0xc0000041, 0xe0000072, 0xa0000003, 0xc0000012, 0x60000041, 0xc0000032,
+			0x20000001, 0xc0000002, 0xe0000042, 0x60000042, 0x80000002, 0x00000000,
+			0x00000000, 0x80000000, 0x00000002, 0x00000040, 0x00000000, 0x80000040,
+			0x80000000, 0x00000040, 0x80000001, 0x00000060, 0x80000003, 0x40000002,
+			0xc0000040, 0xc0000002, 0x80000000, 0x80000000, 0x80000002, 0x00000040,
+			0x00000002, 0x80000000, 0x80000000, 0x80000000, 0x00000002, 0x00000040,
+			0x00000000, 0x80000040, 0x80000002, 0x00000000, 0x80000000, 0x80000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000004, 0x00000080, 0x00000004, 0x00000009, 0x00000105, 0x00000089,
+			0x00000016, 0x0000020b, 0x0000011b, 0x0000012d, 0x0000041e, 0x00000224,
+			0x00000050, 0x0000092e},
+	},
+	{
+		DvType: 2, DvK: 52, DvB: 0, TestT: 65, MaskI: 0, MaskB: 27,
+		Dm: [CheckSize]uint32{
+			0x0c000002, 0xc0000010, 0xb400001c, 0x3c000004, 0xbc00001a, 0x20000010,
+			0x2400001c, 0xec000014, 0x0c000002, 0xc0000010, 0xb400001c, 0x2c000004,
+			0xbc000018, 0xb0000010, 0x0000000c, 0xb8000010, 0x08000018, 0x78000010,
+			0x08000014, 0x70000010, 0xb800001c, 0xe8000000, 0xb0000004, 0x58000010,
+			0xb000000c, 0x48000000, 0xb0000000, 0xb8000010, 0x98000010, 0xa0000000,
+			0x00000000, 0x00000000, 0x20000000, 0x80000000, 0x00000010, 0x00000000,
+			0x20000010, 0x20000000, 0x00000010, 0x60000000, 0x00000018, 0xe0000000,
+			0x90000000, 0x30000010, 0xb0000000, 0x20000000, 0x20000000, 0xa0000000,
+			0x00000010, 0x80000000, 0x20000000, 0x20000000, 0x20000000, 0x80000000,
+			0x00000010, 0x00000000, 0x20000010, 0xa0000000, 0x00000000, 0x20000000,
+			0x20000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000001, 0x00000020, 0x00000001, 0x40000002, 0x40000041,
+			0x40000022, 0x80000005, 0xc0000082, 0xc0000046, 0x4000004b, 0x80000107,
+			0x00000089, 0x00000014},
+	},
+	{
+		DvType: 2, DvK: 53, DvB: 0, TestT: 65, MaskI: 0, MaskB: 28,
+		Dm: [CheckSize]uint32{
+			0xcc000014, 0x0c000002, 0xc0000010, 0xb400001c, 0x3c000004, 0xbc00001a,
+			0x20000010, 0x2400001c, 0xec000014, 0x0c000002, 0xc0000010, 0xb400001c,
+			0x2c000004, 0xbc000018, 0xb0000010, 0x0000000c, 0xb8000010, 0x08000018,
+			0x78000010, 0x08000014, 0x70000010, 0xb800001c, 0xe8000000, 0xb0000004,
+			0x58000010, 0xb000000c, 0x48000000, 0xb0000000, 0xb8000010, 0x98000010,
+			0xa0000000, 0x00000000, 0x00000000, 0x20000000, 0x80000000, 0x00000010,
+			0x00000000, 0x20000010, 0x20000000, 0x00000010, 0x60000000, 0x00000018,
+			0xe0000000, 0x90000000, 0x30000010, 0xb0000000, 0x20000000, 0x20000000,
+			0xa0000000, 0x00000010, 0x80000000, 0x20000000, 0x20000000, 0x20000000,
+			0x80000000, 0x00000010, 0x00000000, 0x20000010, 0xa0000000, 0x00000000,
+			0x20000000, 0x20000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000001, 0x00000020, 0x00000001, 0x40000002,
+			0x40000041, 0x40000022, 0x80000005, 0xc0000082, 0xc0000046, 0x4000004b,
+			0x80000107, 0x00000089},
+	},
+	{
+		DvType: 2, DvK: 54, DvB: 0, TestT: 65, MaskI: 0, MaskB: 29,
+		Dm: [CheckSize]uint32{
+			0x0400001c, 0xcc000014, 0x0c000002, 0xc0000010, 0xb400001c, 0x3c000004,
+			0xbc00001a, 0x20000010, 0x2400001c, 0xec000014, 0x0c000002, 0xc0000010,
+			0xb400001c, 0x2c000004, 0xbc000018, 0xb0000010, 0x0000000c, 0xb8000010,
+			0x08000018, 0x78000010, 0x08000014, 0x70000010, 0xb800001c, 0xe8000000,
+			0xb0000004, 0x58000010, 0xb000000c, 0x48000000, 0xb0000000, 0xb8000010,
+			0x98000010, 0xa0000000, 0x00000000, 0x00000000, 0x20000000, 0x80000000,
+			0x00000010, 0x00000000, 0x20000010, 0x20000000, 0x00000010, 0x60000000,
+			0x00000018, 0xe0000000, 0x90000000, 0x30000010, 0xb0000000, 0x20000000,
+			0x20000000, 0xa0000000, 0x00000010, 0x80000000, 0x20000000, 0x20000000,
+			0x20000000, 0x80000000, 0x00000010, 0x00000000, 0x20000010, 0xa0000000,
+			0x00000000, 0x20000000, 0x20000000, 0x00000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000020, 0x00000001,
+			0x40000002, 0x40000041, 0x40000022, 0x80000005, 0xc0000082, 0xc0000046,
+			0x4000004b, 0x80000107},
+	},
+	{
+		DvType: 2, DvK: 55, DvB: 0, TestT: 65, MaskI: 0, MaskB: 30,
+		Dm: [CheckSize]uint32{
+			0x00000010, 0x0400001c, 0xcc000014, 0x0c000002, 0xc0000010, 0xb400001c,
+			0x3c000004, 0xbc00001a, 0x20000010, 0x2400001c, 0xec000014, 0x0c000002,
+			0xc0000010, 0xb400001c, 0x2c000004, 0xbc000018, 0xb0000010, 0x0000000c,
+			0xb8000010, 0x08000018, 0x78000010, 0x08000014, 0x70000010, 0xb800001c,
+			0xe8000000, 0xb0000004, 0x58000010, 0xb000000c, 0x48000000, 0xb0000000,
+			0xb8000010, 0x98000010, 0xa0000000, 0x00000000, 0x00000000, 0x20000000,
+			0x80000000, 0x00000010, 0x00000000, 0x20000010, 0x20000000, 0x00000010,
+			0x60000000, 0x00000018, 0xe0000000, 0x90000000, 0x30000010, 0xb0000000,
+			0x20000000, 0x20000000, 0xa0000000, 0x00000010, 0x80000000, 0x20000000,
+			0x20000000, 0x20000000, 0x80000000, 0x00000010, 0x00000000, 0x20000010,
+			0xa0000000, 0x00000000, 0x20000000, 0x20000000, 0x00000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000020,
+			0x00000001, 0x40000002, 0x40000041, 0x40000022, 0x80000005, 0xc0000082,
+			0xc0000046, 0x4000004b},
+	},
+	{
+		DvType: 2, DvK: 56, DvB: 0, TestT: 65, MaskI: 0, MaskB: 31,
+		Dm: [CheckSize]uint32{
+			0x2600001a, 0x00000010, 0x0400001c, 0xcc000014, 0x0c000002, 0xc0000010,
+			0xb400001c, 0x3c000004, 0xbc00001a, 0x20000010, 0x2400001c, 0xec000014,
+			0x0c000002, 0xc0000010, 0xb400001c, 0x2c000004, 0xbc000018, 0xb0000010,
+			0x0000000c, 0xb8000010, 0x08000018, 0x78000010, 0x08000014, 0x70000010,
+			0xb800001c, 0xe8000000, 0xb0000004, 0x58000010, 0xb000000c, 0x48000000,
+			0xb0000000, 0xb8000010, 0x98000010, 0xa0000000, 0x00000000, 0x00000000,
+			0x20000000, 0x80000000, 0x00000010, 0x00000000, 0x20000010, 0x20000000,
+			0x00000010, 0x60000000, 0x00000018, 0xe0000000, 0x90000000, 0x30000010,
+			0xb0000000, 0x20000000, 0x20000000, 0xa0000000, 0x00000010, 0x80000000,
+			0x20000000, 0x20000000, 0x20000000, 0x80000000, 0x00000010, 0x00000000,
+			0x20000010, 0xa0000000, 0x00000000, 0x20000000, 0x20000000, 0x00000000,
+			0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000001,
+			0x00000020, 0x00000001, 0x40000002, 0x40000041, 0x40000022, 0x80000005,
+			0xc0000082, 0xc0000046},
+	},
+	{
+		DvType: 0, DvK: 0, DvB: 0, TestT: 0, MaskI: 0, MaskB: 0,
+		Dm: [CheckSize]uint32{
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0},
+	},
+}
--- a/vendor/github.com/pjbgf/sha1cd/ubc/doc.go
+++ b/vendor/github.com/pjbgf/sha1cd/ubc/doc.go
@@ -0,0 +1,3 @@
+// ubc package provides ways for SHA1 blocks to be checked for
+// Unavoidable Bit Conditions that arise from crypto analysis attacks.
+package ubc