// Reset is needed to satisfy the hash.Hash interface, but should never be
// used to authenticate a different message under the same key.
165683
func (d *digest) Reset() {
	k := d.key

	/* r &= 0xffffffc0ffffffc0ffffffc0fffffff */
	d.r[0] = ((uint32(k[ 0]) | uint32(k[ 1])<<8 | uint32(k[ 2])<<16 | uint32(k[ 3])<<24)     ) & 0x3ffffff
	d.r[1] = ((uint32(k[ 3]) | uint32(k[ 4])<<8 | uint32(k[ 5])<<16 | uint32(k[ 6])<<24) >> 2) & 0x3ffff03
	d.r[2] = ((uint32(k[ 6]) | uint32(k[ 7])<<8 | uint32(k[ 8])<<16 | uint32(k[ 9])<<24) >> 4) & 0x3ffc0ff
	d.r[3] = ((uint32(k[ 9]) | uint32(k[10])<<8 | uint32(k[11])<<16 | uint32(k[12])<<24) >> 6) & 0x3f03fff
	d.r[4] = ((uint32(k[12]) | uint32(k[13])<<8 | uint32(k[14])<<16 | uint32(k[15])<<24) >> 8) & 0x00fffff

	d.pad[0] = uint32(k[16]) | uint32(k[17])<<8 | uint32(k[18])<<16 | uint32(k[19])<<24
	d.pad[1] = uint32(k[20]) | uint32(k[21])<<8 | uint32(k[22])<<16 | uint32(k[23])<<24
	d.pad[2] = uint32(k[24]) | uint32(k[25])<<8 | uint32(k[26])<<16 | uint32(k[27])<<24
	d.pad[3] = uint32(k[28]) | uint32(k[29])<<8 | uint32(k[30])<<16 | uint32(k[31])<<24

	d.h[0] = 0
	d.h[1] = 0
	d.h[2] = 0
	d.h[3] = 0
	d.h[4] = 0
}
276881
func (s *Socket) reset(addr net.Addr, ackNr, connId uint16) {
	b := make([]byte, 0, maxHeaderSize)
	h := header{
		Type:    stReset,
		Version: 1,
		ConnID:  connId,
		AckNr:   ackNr,
	}
	b = b[:h.Marshal(b)]
	go s.writeTo(b, addr)
}
1014261
func (xxh *xxHash) Reset() {
	xxh.v1 = xxh.seed + prime64_1 + prime64_2
	xxh.v2 = xxh.seed + prime64_2
	xxh.v3 = xxh.seed
	xxh.v4 = xxh.seed - prime64_1
	xxh.totalLen = 0
	xxh.bufused = 0
}
41298
func (b *Batch) Reset() {
	b.data = b.data[:0]
	b.index = b.index[:0]
	b.internalLen = 0
}
449508
func (i *FSTIterator) Reset(f *FST,
	startKeyInclusive, endKeyExclusive []byte, aut Automaton) error {
	if aut == nil {
		aut = alwaysMatchAutomaton
	}

	i.f = f
	i.startKeyInclusive = startKeyInclusive
	i.endKeyExclusive = endKeyExclusive
	i.aut = aut

	return i.pointTo(startKeyInclusive)
}
908116
func (c *Cacher) Reset(data map[string]interface{}) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.data = data
}
1202495
func (s *DynamicBanScore) Reset() {
	s.mtx.Lock()
	s.persistent = 0
	s.transient = 0
	s.lastUnix = 0
	s.mtx.Unlock()
}
602427
func (m *MockBytes) Reset(arg0 []byte) {
	m.ctrl.Call(m, "Reset", arg0)
}
1143428
func (c *Cache) Reset() {
	c.Lock()
	defer c.Unlock()
	c.m = make(map[string]*list.Element, c.config.MaxItems)
	c.l.Init()
	c.size = 0
}
756614
func (c *Cache) Reset() {
	c.lock.Lock()
	defer c.lock.Unlock()

	c.cache = make(map[interface{}]*list.Element)
	c.lru.Init()
}
1191095
func (s *secrets) Reset() {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.m = make(map[string]*api.Secret)
}
71503
func (m *HashMap) Reset() {
	for i := int64(0); i < m.capacity; i++ {
		m.hashes[i] = 0
		m.elems[i].reset()
	}
	m.n = 0
	m.tracker.SetSize(0)
}
1282846
func (d *state) Reset() {
	// Zero the permutation's state.
	for i := range d.a {
		d.a[i] = 0
	}
	d.state = spongeAbsorbing
	d.buf = d.storage[:0]
}
1184996
func (m *MemLogger) Reset() {
	if m.lock != nil {
		m.lock.Lock()
		defer m.lock.Unlock()
	}
	if m.data != nil {
		*m.data = nil
	}
}
1138783
func (req *Request) Reset() {
	req.Headers = map[string]string{}
	for k, v := range DefaultHeaders {
		req.Headers[k] = v
	}
	req.Cookies = nil
	req.Data = nil
	req.Params = nil
	req.Files = nil
	req.Json = nil
	req.Proxy = ""
	req.BasicAuth = BasicAuth{}
	req.Body = nil
	return
}
717850
func (this *HttpClient) reset() {
	this.oneTimeOptions = nil
	this.oneTimeHeaders = nil
	this.oneTimeCookies = nil
	this.reuseTransport = true
	this.reuseJar = true

	// nil means the Begin has not been called, asume requests are not
	// concurrent.
	if this.withLock {
		this.lock.Unlock()
	}
}
1143948
func (sm *StateMachine) Reset(in *Msg) {
	sm.state = 0
	sm.stateEntered = false
	sm.plugin.SetMemory(in, StateKey, 0)
	sm.plugin.SetMemory(in, stateEnteredKey, false)
	sm.resetFn(in)
}