code: func NewEncoding(encoder string, base256BlockLen int, skipBytes string) *Encoding {
  
  	base := len(encoder)
  
  	logOfBase := math.Log2(float64(base))
  
  	// If input blocks are base256BlockLen size, compute the corresponding
  	// output block length.  We need to round up to fit the overflow.
  	baseXBlockLen := int(math.Ceil(float64(8*base256BlockLen) / logOfBase))
  
  	// Code adapted from encoding/base64/base64.go in the standard
  	// Go libraries.
  	e := &Encoding{
  		encode:          make([]byte, base),
  		base:            base,
  		base256BlockLen: base256BlockLen,
  		baseXBlockLen:   baseXBlockLen,
  		logOfBase:       logOfBase,
  		baseBig:         big.NewInt(int64(base)),
  		skipBytes:       skipBytes,
  	}
  	copy(e.encode[:], encoder)
  
  	for _, c := range skipBytes {
  		e.skipMap[c] = true
  	}
  	for i := 0; i < len(encoder); i++ {
  		e.decodeMap[encoder[i]] = big.NewInt(int64(i))
  	}
  	return e
  }
docs: // NewEncoding returns a new Encoding defined by the given alphabet,
  // which must a x-byte string. No padding options are currently allowed.
  // inBlock is the size of input blocks to consider.
  //
  // For base 58, we recommend 19-byte
  // input blocks, which encode to 26-byte output blocks with only .3 bits
  // wasted per block. The name of the game is to find a good rational
  // approximation of 8/log2(58), and 26/19 is pretty good!