func (t *Tree) DeleteMin(fast bool) {
	if t.Root == nil {
		return
	}
	var d int
	t.Root, d = t.Root.deleteMin(fast)
	t.Count += d
	if t.Root == nil {
		return
	}
	t.Root.Color = llrb.Black
}
DeleteMin deletes the left-most interval.
package interval
import (
	"errors"
	"github.com/biogo/store/llrb"
)
const (
	TD234 = iota
	BU23
)
func init() {
	if Mode != TD234 && Mode != BU23 {
		panic("interval: unknown mode")
	}
}
var ErrInvertedRange = errors.New("interval: inverted range")
type Overlapper interface {
	Overlap(Range) bool
}
type Range interface {
	Start() Comparable
	End() Comparable
}
type Interface interface {
	Overlapper
	Range
	ID() uintptr          
	NewMutable() Mutable  
}
type Mutable interface {
	Range
	SetStart(Comparable)  
	SetEnd(Comparable)    
}
type Comparable interface {
	Compare(Comparable) int
}
type Node struct {
	Elem        Interface
	Range       Mutable
	Left, Right *Node
	Color       llrb.Color
}
type Tree struct {
	Root  *Node  
	Count int    
}
func (n *Node) color() llrb.Color {
	if n == nil {
		return llrb.Black
	}
	return n.Color
}
func maxRange(root, left, right *Node) Comparable {
	end := root.Elem.End()
	if left != nil && left.Range.End().Compare(end) > 0 {
		end = left.Range.End()
	}
	if right != nil && right.Range.End().Compare(end) > 0 {
		end = right.Range.End()
	}
	return end
}
func (n *Node) rotateLeft() (root *Node) {
	root = n.Right
	n.Right = root.Left
	root.Left = n
	root.Color = n.Color
	n.Color = llrb.Red
	root.Left.Range.SetEnd(maxRange(root.Left, root.Left.Left, root.Left.Right))
	if root.Left == nil {
		root.Range.SetStart(root.Elem.Start())
	} else {
		root.Range.SetStart(root.Left.Range.Start())
	}
	root.Range.SetEnd(maxRange(root, root.Left, root.Right))
	return
}
func (n *Node) rotateRight() (root *Node) {
	root = n.Left
	n.Left = root.Right
	root.Right = n
	root.Color = n.Color
	n.Color = llrb.Red
	if root.Right.Left == nil {
		root.Right.Range.SetStart(root.Right.Elem.Start())
	} else {
		root.Right.Range.SetStart(root.Right.Left.Range.Start())
	}
	root.Right.Range.SetEnd(maxRange(root.Right, root.Right.Left, root.Right.Right))
	root.Range.SetEnd(maxRange(root, root.Left, root.Right))
	return
}
func (n *Node) flipColors() {
	n.Color = !n.Color
	n.Left.Color = !n.Left.Color
	n.Right.Color = !n.Right.Color
}
func (n *Node) fixUp(fast bool) *Node {
	if !fast {
		n.adjustRange()
	}
	if n.Right.color() == llrb.Red {
		if Mode == TD234 && n.Right.Left.color() == llrb.Red {
			n.Right = n.Right.rotateRight()
		}
		n = n.rotateLeft()
	}
	if n.Left.color() == llrb.Red && n.Left.Left.color() == llrb.Red {
		n = n.rotateRight()
	}
	if Mode == BU23 && n.Left.color() == llrb.Red && n.Right.color() == llrb.Red {
		n.flipColors()
	}
	return n
}
func (n *Node) adjustRange() {
	if n.Left == nil {
		n.Range.SetStart(n.Elem.Start())
	} else {
		n.Range.SetStart(n.Left.Range.Start())
	}
	n.Range.SetEnd(maxRange(n, n.Left, n.Right))
}
func (n *Node) moveRedLeft() *Node {
	n.flipColors()
	if n.Right.Left.color() == llrb.Red {
		n.Right = n.Right.rotateRight()
		n = n.rotateLeft()
		n.flipColors()
		if Mode == TD234 && n.Right.Right.color() == llrb.Red {
			n.Right = n.Right.rotateLeft()
		}
	}
	return n
}
func (n *Node) moveRedRight() *Node {
	n.flipColors()
	if n.Left.Left.color() == llrb.Red {
		n = n.rotateRight()
		n.flipColors()
	}
	return n
}
func (t *Tree) Len() int {
	return t.Count
}
func (t *Tree) Get(q Overlapper) (o []Interface) {
	if t.Root != nil && q.Overlap(t.Root.Range) {
		t.Root.doMatch(func(e Interface) (done bool) { o = append(o, e); return }, q)
	}
	return
}
func (t *Tree) AdjustRanges() {
	if t.Root == nil {
		return
	}
	t.Root.adjustRanges()
}
func (n *Node) adjustRanges() {
	if n.Left != nil {
		n.Left.adjustRanges()
	}
	if n.Right != nil {
		n.Right.adjustRanges()
	}
	n.adjustRange()
}
func (t *Tree) Insert(e Interface, fast bool) (err error) {
	if e.Start().Compare(e.End()) > 0 {
		return ErrInvertedRange
	}
	var d int
	t.Root, d = t.Root.insert(e, e.Start(), e.ID(), fast)
	t.Count += d
	t.Root.Color = llrb.Black
	return
}
func (n *Node) insert(e Interface, min Comparable, id uintptr, fast bool) (root *Node, d int) {
	if n == nil {
		return &Node{Elem: e, Range: e.NewMutable()}, 1
	} else if n.Elem == nil {
		n.Elem = e
		if !fast {
			n.adjustRange()
		}
		return n, 1
	}
	if Mode == TD234 {
		if n.Left.color() == llrb.Red && n.Right.color() == llrb.Red {
			n.flipColors()
		}
	}
	switch c := min.Compare(n.Elem.Start()); {
	case c == 0:
		switch {
		case id == n.Elem.ID():
			n.Elem = e
			if !fast {
				n.Range.SetEnd(e.End())
			}
		case id < n.Elem.ID():
			n.Left, d = n.Left.insert(e, min, id, fast)
		default:
			n.Right, d = n.Right.insert(e, min, id, fast)
		}
	case c < 0:
		n.Left, d = n.Left.insert(e, min, id, fast)
	default:
		n.Right, d = n.Right.insert(e, min, id, fast)
	}
	if n.Right.color() == llrb.Red && n.Left.color() == llrb.Black {
		n = n.rotateLeft()
	}
	if n.Left.color() == llrb.Red && n.Left.Left.color() == llrb.Red {
		n = n.rotateRight()
	}
	if Mode == BU23 {
		if n.Left.color() == llrb.Red && n.Right.color() == llrb.Red {
			n.flipColors()
		}
	}
	if !fast {
		n.adjustRange()
	}
	root = n
	return
}