func ordered(db *db.DB, a *assignment.Assignment) (l *cnf.Lit) {
	// find the first in-order unassigned literal
	for i := uint(1); i <= a.Len(); i++ {
		if p, _ := a.Get(i); p == guess.Unassigned {
			return &cnf.Lit{i, cnf.Pos}
		}
	}
	return &cnf.Lit{0, 0}
}

func (lc *LitCounts) GetNextVmtf(a *assignment.Assignment) (l *cnf.Lit) {
	var lit uint
	for i := range lc.vmtf {
		if lc.vmtf[i].lit < 0 {
			lit = uint(-1 * lc.vmtf[i].lit)
		} else {
			lit = uint(lc.vmtf[i].lit)
		}
		if val, err := a.Get(lit); val == guess.Unassigned && err == nil {
			if lc.vmtf[i].lit < 0 {
				return &cnf.Lit{uint(lc.vmtf[i].lit * -1), cnf.Pos}
			} else {
				return &cnf.Lit{uint(lc.vmtf[i].lit), cnf.Pos}
			}
		}
	}
	panic("getNextVmtf is broken")
}

// We'll use a modified MOMS rule that only looks at binary clauses
func moms(db *db.DB, a *assignment.Assignment) (l *cnf.Lit) {
	var (
		counts   = make([]int, a.Guess().Len())
		eCount   int
		vals     [2]uint
		g        = a.Guess()
		biggest  = 0
		biggestI = -1
	)

	// Count up the total lits in binary clauses
	for e := db.Learned; e != nil; e = e.Next {
		eCount = 0
		for _, l := range e.Clause.Lits {
			if v, _ := g.Get(l.Val); v == guess.Unassigned {
				eCount++
				if eCount > 2 {
					break
				}
				vals[eCount-1] = l.Val
			}
		}
		if eCount <= 2 {
			for i := 0; i < eCount; i++ {
				counts[vals[i]-1]++
			}
		}
	}

	// Search for the biggest
	for i, v := range counts {
		if v > biggest {
			biggest = v
			biggestI = i
		}
	}

	if biggestI == -1 {
		return random(db, a)
	} else {
		return &cnf.Lit{uint(biggestI + 1), byte((rand.Int() % 2) + 1)}
	}
	panic("MOMS is broken")
}

func random(db *db.DB, a *assignment.Assignment) (l *cnf.Lit) {
	sign := byte((rand.Int() % 2) + 1)
	val := uint((rand.Int() % int(a.Len())) + 1)
	for i := val; i <= a.Len(); i++ {
		if v, _ := a.Get(i); v == guess.Unassigned {
			return &cnf.Lit{i, sign}
		}
	}
	for i := uint(1); i < val; i++ {
		if v, _ := a.Get(i); v == guess.Unassigned {
			return &cnf.Lit{i, sign}
		}
	}
	return &cnf.Lit{0, 0}
}

func DpllTimeout(cdb *db.DB, a *assignment.Assignment, b *Brancher, m *db.Manager, adapt *Adapter, timeout <-chan time.Time) *guess.Guess {

	nVar := a.Guess().Len()
	aStack := make([]dpllStackNode, nVar)
	top := -1

	for {

		top++
		aStack[top].l = b.Decide(cdb, a)
		aStack[top].Flipped = false
		a.PushAssign(aStack[top].l.Val, aStack[top].l.Pol)

		for {
			select {
			case <-timeout:
				return nil
			default:
			}

			status := cdb.Bcp(a.Guess(), *aStack[top].l, m)
			if status == db.Conflict {
				// BackTrack
				for aStack[top].Flipped == true {
					top--
					a.PopAssign()
				}
				if top < 0 {
					return nil
				}
				// Flip the assignment
				a.PopAssign()
				aStack[top].l.Flip()
				aStack[top].Flipped = true
				a.PushAssign(aStack[top].l.Val, aStack[top].l.Pol)
				// Reconfigure if neccessary
				if adapt != nil {
					adapt.Reconfigure(cdb, b, m)
				}

			} else if status == db.Sat {
				return a.Guess()
			} else {
				break
			}
		}
	}
	panic("Dpll is broken")
}

func vsids(db *db.DB, a *assignment.Assignment) (l *cnf.Lit) {
	l = db.Counts.Max(a.Guess())
	return
}