if serverSideChecksum != nil {
			fi.Checksum = serverSideChecksum.AppendTo(nil, nil)
			if opts.EncryptFn != nil {
				fi.Checksum = opts.EncryptFn("object-checksum", fi.Checksum)
			}
		}
	} else if fi.Checksum == nil && opts.WantChecksum != nil {
		// Trailing headers checksums should now be filled.
		fi.Checksum = opts.WantChecksum.AppendTo(nil, nil)
		if opts.EncryptFn != nil {

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        writeLittleEndianInt(baos, PacSignature.KERB_CHECKSUM_HMAC_MD5);
        byte[] checksum = new byte[16];
        for (int i = 0; i < checksum.length; i++) {
            checksum[i] = (byte) i;
        }
        baos.write(checksum);
        byte[] data = baos.toByteArray();

        // Create PacSignature
        PacSignature pacSignature = new PacSignature(data);

        } catch (final IOException e) {
            throw new PACDecodingException("Malformed PAC signature", e);
        }
    }

    /**
     * Gets the checksum type of this signature.
     *
     * @return the checksum type constant
     */
    public int getType() {
        return this.type;
    }

    /**
     * Gets the checksum data.
     *
     * @return the checksum bytes
     */

const minIOErasureUpgraded = "x-minio-internal-erasure-upgraded"

const erasureAlgorithm = "rs-vandermonde"

// GetChecksumInfo - get checksum of a part.
func (e ErasureInfo) GetChecksumInfo(partNumber int) (ckSum ChecksumInfo) {
	for _, sum := range e.Checksums {
		if sum.PartNumber == partNumber {
			// Return the checksum
			return sum
		}
	}
	return ChecksumInfo{Algorithm: DefaultBitrotAlgorithm}
}

				if err != nil {
					err = msgp.WrapError(err, "MinioEnv", za0002)
					return
				}
				z.MinioEnv[za0002] = za0003
			}
		case "Checksum":
			z.Checksum, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Checksum")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

         */
        @Nonnull
        String getName();

        /**
         * Returns the file extension to be used for given checksum file (without leading dot), never {@code null}. The
         * extension should be file and URL path friendly, and may differ from algorithm name.
         * The checksum extension SHOULD NOT contain dot (".") character.
         * Example: "sha1".
         */
        @Nonnull

	"hash/crc64"
	"math/bits"
)

// AddPart will merge a part checksum into the current,
// as if the content of each was appended.
// The size of the content that produced the second checksum must be provided.
// Not all checksum types can be merged, use the CanMerge method to check.
// Checksum types must match.
func (c *Checksum) AddPart(other Checksum, size int64) error {
	if !other.Type.CanMerge() {

			hash.Write(msg)
			sum = hash.Sum(sum[:0])
			msg = append(msg, sum...)
			hash.Reset()
		}
		if !bytes.Equal(sum, checksum) {
			logger.Fatal(errSelfTestFailure, fmt.Sprintf("bitrot: %v selftest checksum mismatch: got %x - want %x", algorithm, sum, checksum))
		}
	}

                        // file...we'll try again with the MD5 checksum.
                        try {
                            verifyChecksum(md5ChecksumObserver, destination, temp, remotePath, ".md5", wagon);
                        } catch (ChecksumFailedException e) {
                            // if we also fail to verify based on the MD5 checksum, and the checksum transfer/read

	// Content Checksums
	AmzChecksumAlgo           = "x-amz-checksum-algorithm"
	AmzChecksumCRC32          = "x-amz-checksum-crc32"
	AmzChecksumCRC32C         = "x-amz-checksum-crc32c"
	AmzChecksumSHA1           = "x-amz-checksum-sha1"
	AmzChecksumSHA256         = "x-amz-checksum-sha256"
	AmzChecksumCRC64NVME      = "x-amz-checksum-crc64nvme"
	AmzChecksumMode           = "x-amz-checksum-mode"
	AmzChecksumType           = "x-amz-checksum-type"