CNEG  LO, R7, R15                          // ef2487da
	CRC32B R17, R8, R16                        // 1041d11a
	CRC32H R3, R21, R27                        // bb46c31a
	CRC32W R22, R30, R9                        // c94bd61a
	CRC32X R20, R4, R15                        // 8f4cd49a
	CRC32CB R19, R27, R22                      // 7653d31a
	CRC32CH R21, R0, R20                       // 1454d51a
	CRC32CW R9, R3, R21                        // 7558c91a

		}
		if got.Flags != want.flags {
			t.Errorf("%s: got Flags %#x; want %#x", want.name, got.Flags, want.flags)
		}
		if got.CRC32 != want.crc32 {
			t.Errorf("%s: got CRC32 %#x; want %#x", want.name, got.CRC32, want.crc32)
		}
		if got.CompressedSize64 != want.compressedSize {
			t.Errorf("%s: got CompressedSize64 %d; want %d", want.name, got.CompressedSize64, want.compressedSize)
		}

		w, err := zw.CreateRaw(&zip.FileHeader{
			Name:               name,
			Method:             zip.Store,
			CompressedSize64:   uint64(len(data)),
			UncompressedSize64: uint64(len(data)),
			CRC32:              crc32.ChecksumIEEE(data),
		})
		if err != nil {
			log.Fatal(err)
		}
		if _, err := w.Write(data); err != nil {
			log.Fatal(err)
		}
		seen[name] = true
		return nil
	})
	if err != nil {

		fh.UncompressedSize64 = 0

		ow = dirWriter{}
	} else {
		fh.Flags |= 0x8 // we will write a data descriptor

		fw = &fileWriter{
			zipw:      w.cw,
			compCount: &countWriter{w: w.cw},
			crc32:     crc32.NewIEEE(),
		}
		comp := w.compressor(fh.Method)
		if comp == nil {
			return nil, ErrAlgorithm
		}
		var err error
		fw.comp, err = comp(fw.compCount)
		if err != nil {
			return nil, err

Russ Cox <******@****.***> 1410149331 -0400

	CRC32W R11, R11                         // 66f2450f38f1db
	CRC32L (BX), DX                         // f20f38f113
	CRC32L (R11), DX                        // f2410f38f113
	CRC32L DX, DX                           // f20f38f1d2
	CRC32L R11, DX                          // f2410f38f1d3
	CRC32L (BX), R11                        // f2440f38f11b
	CRC32L (R11), R11                       // f2450f38f11b
	CRC32L DX, R11                          // f2440f38f1da

func hashOrder(key string, cardinality int) []int {
	if cardinality <= 0 {
		// Returns an empty int slice for cardinality < 0.
		return nil
	}

	nums := make([]int, cardinality)
	keyCrc := crc32.Checksum([]byte(key), crc32.IEEETable)

	start := int(keyCrc % uint32(cardinality))
	for i := 1; i <= cardinality; i++ {
		nums[i-1] = 1 + ((start + i) % cardinality)
	}
	return nums
}

var (

/**
 * An enum that contains all of the known hash functions.
 *
 * @author Kurt Alfred Kluever
 */
@NullUnmarked
enum HashFunctionEnum {
  ADLER32(Hashing.adler32()),
  CRC32(Hashing.crc32()),
  GOOD_FAST_HASH_32(Hashing.goodFastHash(32)),
  GOOD_FAST_HASH_64(Hashing.goodFastHash(64)),
  GOOD_FAST_HASH_128(Hashing.goodFastHash(128)),
  GOOD_FAST_HASH_256(Hashing.goodFastHash(256)),
  MD5(Hashing.md5()),

	// Deprecated: Use Modified instead.
	ModifiedTime uint16

	// ModifiedDate is an MS-DOS-encoded date.
	//
	// Deprecated: Use Modified instead.
	ModifiedDate uint16

	// CRC32 is the CRC32 checksum of the file content.
	CRC32 uint32

	// CompressedSize is the compressed size of the file in bytes.
	// If either the uncompressed or compressed size of the file

				} else {
					err = err1
				}
			} else if r.hash.Sum32() != r.f.CRC32 {
				err = ErrChecksum
			}
		} else {
			// If there's not a data descriptor, we still compare
			// the CRC32 of what we've read against the file header
			// or TOC's CRC32, if it seems like it was set.
			if r.f.CRC32 != 0 && r.hash.Sum32() != r.f.CRC32 {
				err = ErrChecksum
			}
		}
	}
	r.err = err
	return
}