code: func (a *Allocator) ReleaseAddress(poolID string, address net.IP) error {
  	logrus.Debugf("ReleaseAddress(%s, %v)", poolID, address)
  	k := SubnetKey{}
  	if err := k.FromString(poolID); err != nil {
  		return types.BadRequestErrorf("invalid pool id: %s", poolID)
  	}
  
  	if err := a.refresh(k.AddressSpace); err != nil {
  		return err
  	}
  
  	aSpace, err := a.getAddrSpace(k.AddressSpace)
  	if err != nil {
  		return err
  	}
  
  	aSpace.Lock()
  	p, ok := aSpace.subnets[k]
  	if !ok {
  		aSpace.Unlock()
  		return types.NotFoundErrorf("cannot find address pool for poolID:%s", poolID)
  	}
  
  	if address == nil {
  		aSpace.Unlock()
  		return types.BadRequestErrorf("invalid address: nil")
  	}
  
  	if !p.Pool.Contains(address) {
  		aSpace.Unlock()
  		return ipamapi.ErrIPOutOfRange
  	}
  
  	c := p
  	for c.Range != nil {
  		k = c.ParentKey
  		c = aSpace.subnets[k]
  	}
  	aSpace.Unlock()
  
  	mask := p.Pool.Mask
  
  	h, err := types.GetHostPartIP(address, mask)
  	if err != nil {
  		return types.InternalErrorf("failed to release address %s: %v", address.String(), err)
  	}
  
  	bm, err := a.retrieveBitmask(k, c.Pool)
  	if err != nil {
  		return types.InternalErrorf("could not find bitmask in datastore for %s on address %v release from pool %s: %v",
  			k.String(), address, poolID, err)
  	}
  	defer logrus.Debugf("Released address PoolID:%s, Address:%v Sequence:%s", poolID, address, bm.String())
  
  	return bm.Unset(ipToUint64(h))
  }
docs: // ReleaseAddress releases the address from the specified pool ID