code: func getFirstAvailable(head *sequence, start uint64) (uint64, uint64, error) {
  	// Find sequence which contains the start bit
  	byteStart, bitStart := ordinalToPos(start)
  	current, _, precBlocks, inBlockBytePos := findSequence(head, byteStart)
  	// Derive the this sequence offsets
  	byteOffset := byteStart - inBlockBytePos
  	bitOffset := inBlockBytePos*8 + bitStart
  	for current != nil {
  		if current.block != blockMAX {
  			// If the current block is not full, check if there is any bit
  			// from the current bit in the current block. If not, before proceeding to the
  			// next block node, make sure we check for available bit in the next
  			// instance of the same block. Due to RLE same block signature will be
  			// compressed.
  		retry:
  			bytePos, bitPos, err := current.getAvailableBit(bitOffset)
  			if err != nil && precBlocks == current.count-1 {
  				// This is the last instance in the same block node,
  				// so move to the next block.
  				goto next
  			}
  			if err != nil {
  				// There are some more instances of the same block, so add the offset
  				// and be optimistic that you will find the available bit in the next
  				// instance of the same block.
  				bitOffset = 0
  				byteOffset += blockBytes
  				precBlocks++
  				goto retry
  			}
  			return byteOffset + bytePos, bitPos, err
  		}
  		// Moving to next block: Reset bit offset.
  	next:
  		bitOffset = 0
  		byteOffset += (current.count * blockBytes) - (precBlocks * blockBytes)
  		precBlocks = 0
  		current = current.next
  	}
  	return invalidPos, invalidPos, ErrNoBitAvailable
  }
docs: // getFirstAvailable looks for the first unset bit in passed mask starting from start