func GetUserStore(dir string) (*UserFileStore, error) {
	var bf *fmap.BlockFile
	var users *bptree.BpTree
	path := filepath.Join(dir, "users.bptree")
	err := createOrOpen(path,
		func(path string) (err error) {
			bf, err = fmap.CreateBlockFile(path)
			if err != nil {
				return err
			}
			users, err = bptree.New(bf, -1, -1)
			return err
		},
		func(path string) (err error) {
			bf, err = fmap.OpenBlockFile(path)
			if err != nil {
				return err
			}
			users, err = bptree.Open(bf)
			return err
		},
	)
	if err != nil {
		return nil, err
	}
	s := &UserFileStore{
		path:  path,
		bf:    bf,
		users: users,
	}
	return s, bf.Sync()
}

func NewAt(bf *fmap.BlockFile, ctrl_a uint64) (*List, error) {
	vc_a, err := bf.Allocate()
	if err != nil {
		return nil, err
	}
	it_a, err := bf.Allocate()
	if err != nil {
		return nil, err
	}
	v, err := bptree.NewVarchar(bf, vc_a)
	if err != nil {
		return nil, err
	}
	it, err := bptree.NewAt(bf, it_a, 8, 8)
	if err != nil {
		return nil, err
	}
	l := &List{
		bf:      bf,
		varchar: v,
		idxTree: it,
		a:       ctrl_a,
		count:   0,
	}
	err = l.bf.Do(ctrl_a, 1, func(bytes []byte) error {
		c := l.asCtrl(bytes)
		c.Init(vc_a, it_a)
		return nil
	})
	if err != nil {
		return nil, err
	}
	return l, nil
}

// Open a varchar structure in the given blockfile with the given offset
// as the control block. This function will confirm that the control
// block is indeed a properly formated control block.
func OpenVarchar(bf *fmap.BlockFile, a uint64) (v *Varchar, err error) {
	v = &Varchar{bf: bf, a: a, blkSize: bf.BlockSize()}
	var ptOff uint64
	var szOff uint64
	err = v.bf.Do(v.a, 1, func(bytes []byte) error {
		ctrl := asCtrl(bytes)
		if ctrl.flags&consts.VARCHAR_CTRL == 0 {
			return errors.Errorf("Expected a Varchar control block")
		}
		ptOff = ctrl.posTree
		szOff = ctrl.sizeTree
		return nil
	})
	if err != nil {
		return nil, err
	}
	v.posTree, err = OpenAt(bf, ptOff)
	if err != nil {
		return nil, err
	}
	v.sizeTree, err = OpenAt(bf, szOff)
	if err != nil {
		return nil, err
	}
	return v, nil
}

func Open(bf *fmap.BlockFile) (*List, error) {
	data, err := bf.ControlData()
	if err != nil {
		return nil, err
	}
	ctrl_a := *slice.AsUint64(&data)
	return OpenAt(bf, ctrl_a)
}

func New(bf *fmap.BlockFile) (*List, error) {
	ctrl_a, err := bf.Allocate()
	if err != nil {
		return nil, err
	}
	data := make([]byte, 8)
	moff := slice.AsUint64(&data)
	*moff = ctrl_a
	err = bf.SetControlData(data)
	if err != nil {
		return nil, err
	}
	return NewAt(bf, ctrl_a)
}

// Create a new varchar structure. This takes a blockfile and an offset
// of an allocated block. The block becomes the control block for the
// varchar file (storing the free list for the allocator). It is
// important for the parent structure to track the location of this
// control block.
func NewVarchar(bf *fmap.BlockFile, a uint64) (v *Varchar, err error) {
	ptOff, err := bf.Allocate()
	if err != nil {
		return nil, err
	}
	posTree, err := NewAt(bf, ptOff, 8, 0)
	if err != nil {
		return nil, err
	}
	szOff, err := bf.Allocate()
	if err != nil {
		return nil, err
	}
	sizeTree, err := NewAt(bf, szOff, 4, 8)
	if err != nil {
		return nil, err
	}
	v = &Varchar{
		bf:       bf,
		posTree:  posTree,
		sizeTree: sizeTree,
		a:        a,
		blkSize:  bf.BlockSize(),
	}
	err = v.bf.Do(v.a, 1, func(bytes []byte) error {
		ctrl := asCtrl(bytes)
		ctrl.Init(ptOff, szOff)
		return nil
	})
	if err != nil {
		return nil, err
	}
	return v, nil
}

func (t *T) newLeafIn(bf *fmap.BlockFile, a uint64) {
	t.assert_nil(bf.Do(a, 1, func(bytes []byte) error {
		_, err := newLeaf(0, bytes, 8, 8)
		return err
	}))
}

func (t *T) assert_alc(bf *fmap.BlockFile) uint64 {
	a, err := bf.Allocate()
	t.assert_nil(err)
	return a
}