// New384 returns a new crypto.ResumableHash computing the SHA384 checksum.
346496
func New384() crypto.ResumableHash {
	d := new(digest)
	d.is384 = true
	d.Reset()
	return d
}
1225556
func New(h crypto.Hash) *Isolated {
	a := ""
	switch h {
	case crypto.SHA1:
		a = "sha-1"
	case crypto.SHA256:
		a = "sha-256"
	case crypto.SHA512:
		a = "sha-512"
	}
	return &Isolated{
		Algo:    a,
		Version: IsolatedFormatVersion,
		Files:   map[string]File{},
	}
}
1158417
func New(key *[16]byte) hash.Hash64 {
	h := new(hashFunc)
	h.key[0] = *(*uint64)(unsafe.Pointer(&key[0]))
	h.key[1] = *(*uint64)(unsafe.Pointer(&key[8]))
	h.Reset()
	return h
}
673390
func NewChecksummedReader(delegate io.ReadSeeker, interval int, newHash func() hash.Hash32) ChecksummedReader {
	return newChecksummedReaderImpl(delegate, interval, newHash)
}
1263751
func New(pw_cost uint, hmac_key []byte) (*ScryptAuth, error) {
	if pw_cost > 32 {
		return nil, errors.New("scryptauth new() - invalid pw_cost specified")
	}
	if len(hmac_key) != KEYLENGTH {
		return nil, errors.New("scryptauth new() - unsupported hmac_key length")
	}
	return &ScryptAuth{HmacKey: hmac_key, PwCost: pw_cost, R: SCRYPT_CONST_R, P: SCRYPT_CONST_P}, nil
}
590880
func New() crypt.Crypter {
	return &crypter{
		common.Salt{
			MagicPrefix:   []byte(MagicPrefix),
			SaltLenMin:    SaltLenMin,
			SaltLenMax:    SaltLenMax,
			RoundsDefault: RoundsDefault,
			RoundsMin:     RoundsMin,
			RoundsMax:     RoundsMax,
		},
	}
}
1265948
func New(seed uint32) hash.Hash32 {
	xxh := &xxHash{seed: seed}
	xxh.Reset()
	return xxh
}
456826
func NewHashFromBytes(binary []byte) (hash *Hash, _ error) {
	h := new(Hash)
	if err := h.SetBytes(common.CopyBytes(binary)); err != nil {
		return nil, err
	}
	return h, nil
}
463494
func New332c(seed uint32) nhash.HashF32 {
	s := new(State332c)
	s.seed = seed
	s.Reset()
	return s
}
228147
func NewHash(s string) Hash {
	b, _ := hex.DecodeString(s)

	var h Hash
	copy(h[:], b)

	return h
}
935479
func New(c *Config) (hash.Hash, error) {
	if c == nil {
		c = defaultConfig
	} else {
		if c.Size == 0 {
			// Set default size if it's zero.
			c.Size = Size
		}
		if err := verifyConfig(c); err != nil {
			return nil, err
		}
	}
	d := new(digest)
	d.initialize(c)
	return d, nil
}
1073529
func New(hasher func(v interface{}) uint32) *Dtrie {
	if hasher == nil {
		hasher = defaultHasher
	}
	return &Dtrie{
		root:   emptyNode(0, 32),
		hasher: hasher,
	}
}
823996
func NewBreachHintFromHash(hash *chainhash.Hash) BreachHint {
	var hint BreachHint
	copy(hint[:], hash[:BreachHintSize])
	return hint
}
1071626
func New(dataCnt, parityCnt int) (r *RS, err error) {

	err = checkCfg(dataCnt, parityCnt)
	if err != nil {
		return
	}

	e := genEncMatrix(dataCnt, parityCnt)
	g := e[dataCnt*dataCnt:]
	r = &RS{DataCnt: dataCnt, ParityCnt: parityCnt,
		encodeMatrix: e, genMatrix: g, inverseMatrix: new(sync.Map)}
	r.enableCache()

	r.cpu = getCPUFeature()

	return
}
129246
func NewHashCache(maxSize uint) *HashCache {
	return &HashCache{
		sigHashes: make(map[chainhash.Hash]*TxSigHashes, maxSize),
	}
}
479115
func New256(key []byte) hash.Hash {
	s := new(hashFunc)

	if len(key) > 0 {
		s.initialize(32, &Config{Key: key})
	} else {
		copy(s.hVal[:8], iv256[:])
		s.hValCpy = s.hVal
		s.hashsize = 32
		s.tweak[0] = 0
		s.tweak[1] = CfgMessage<<56 | FirstBlock
	}

	return s
}
759684
func Sum384(data []byte) (digest [48]byte) {
	h := New384()
	h.Write(data)
	h.Sum(digest[:0])
	return
}