if err != nil {
		return nil, err
	}
	if isShortcut {
		if bytes.Equal(lnode[:hashLength], key) {
			return rnode[:hashLength], nil
		}
		return nil, nil
	}
	if bitIsSet(key, s.trieHeight-height) {
		// visit right node
		return s.get(rnode, key, batch, 2*iBatch+2, height-1)
	}
	// visit left node
	return s.get(lnode, key, batch, 2*iBatch+1, height-1)
}

	"github.com/spaolacci/murmur3"
)

// defaultLeaf is the Trie default value : hash of 0x0
var defaultLeaf = hasher([]byte{0x0})

const (
	hashLength = 8
)

type hash [hashLength]byte

func bitIsSet(bits []byte, i int) bool {
	return bits[i/8]&(1<<uint(7-i%8)) != 0
}

func hasher(data ...[]byte) []byte {
	hasher := murmur3.New64()
	for i := 0; i < len(data); i++ {
		_, _ = hasher.Write(data[i])
	}

}

// splitKeys divides the array of keys into 2 so they can update left and right branches in parallel
func (s *smt) splitKeys(keys [][]byte, height int) ([][]byte, [][]byte) {
	for i, key := range keys {
		if bitIsSet(key, height) {
			return keys[:i], keys[i:]
		}
	}
	return keys, nil
}

// maybeAddShortcutToKV adds a shortcut key to the keys array to be updated.

cuiweixie <******@****.***> 1664452800 +0800

 * to keep track of which items are filtered out of the source list.
 */
public class ImmutableFilteredList<T> extends AbstractList<T> {

    private final List<T> source;
    private final BitSet filter;

    private ImmutableFilteredList(List<T> source, BitSet filter) {
        this.source = source;
        this.filter = filter;
    }

    /**
     * Creates an {@code ImmutableFilteredList} which contains all the elements of {@code source}.

            // Because they are EXTRA attributes, we consider that a
            // candidate which does NOT provide this value is a better match
            int candidateCount = candidateAttributeSets.length;
            BitSet any = new BitSet(candidateCount);
            for (int c = 0; c < candidateCount; c++) {
                ImmutableAttributes candidateAttributeSet = candidateAttributeSets[c];

        table = (BitSet) table.clone();
        // If only we could actually call BitSet.trimToSize() ourselves...
      }
      this.table = table;
    }

    @Override
    public boolean matches(char c) {
      return table.get(c);
    }

    @Override
    void setBits(BitSet bitSet) {
      bitSet.or(table);
    }
  }

  // Static constant implementation classes

func TestRemove(t *testing.T) {
	tcases := []struct {
		name         string
		bitsSet      []int
		bitsRemove   []int
		expectedMask string
	}{
		{
			name:         "Set bit 0. Remove bit 0",
			bitsSet:      []int{0},
			bitsRemove:   []int{0},
			expectedMask: "00",
		},
		{
			name:         "Set bits 0 and 1. Remove bit 1",
			bitsSet:      []int{0, 1},
			bitsRemove:   []int{1},
			expectedMask: "01",
		},

package com.google.common.base;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.CharMatcher.NamedFastMatcher;
import java.util.BitSet;

/**
 * An immutable version of CharMatcher for smallish sets of characters that uses a hash table with
 * linear probing to check for matches.
 *
 * @author Christopher Swenson
 */

        table = (BitSet) table.clone();
        // If only we could actually call BitSet.trimToSize() ourselves...
      }
      this.table = table;
    }

    @Override
    public boolean matches(char c) {
      return table.get(c);
    }

    @Override
    void setBits(BitSet bitSet) {
      bitSet.or(table);
    }
  }

  // Static constant implementation classes