func (g *Gini) ActivateWith(act z.Lit) {
	g.xo.ActivateWith(act)
}
ActivateWith allows the caller to specify the activation literal.  It is
useful when the caller needs to activate many clauses with one literal.
However, please note that activation literals are volatile and will be
recycled on Deactivate.  As with Activate, ActivateWith should not
be used to activate the empty clause.  In this case, ActivateWith
panics and subsequent behavior of g is undefined.

ActivateWith is an unsupported operation under a test scope
and will panic if called under a test scope.
package gini
import (
	"io"
	"time"
	"github.com/go-air/gini/dimacs"
	"github.com/go-air/gini/inter"
	"github.com/go-air/gini/internal/xo"
	"github.com/go-air/gini/z"
)
type Gini struct {
	xo *xo.S
}
func newGiniXo(x *xo.S) *Gini {
	g := &Gini{
		xo: x}
	return g
}
func New() *Gini {
	g := &Gini{
		xo: xo.NewS()}
	return g
}
func NewDimacs(r io.Reader) (*Gini, error) {
	vis := &xo.DimacsVis{}
	if e := dimacs.ReadCnf(r, vis); e != nil {
		return nil, e
	}
	g := &Gini{
		xo: vis.S()}
	return g, nil
}
func NewV(capHint int) *Gini {
	g := &Gini{
		xo: xo.NewSV(capHint)}
	return g
}
func NewVc(vCapHint, cCapHint int) *Gini {
	g := &Gini{
		xo: xo.NewSVc(vCapHint, cCapHint)}
	return g
}
func (g *Gini) Copy() *Gini {
	other := &Gini{
		xo: g.xo.Copy()}
	return other
}
func (g *Gini) SCopy() inter.S {
	return g.Copy()
}
func (g *Gini) MaxVar() z.Var {
	return g.xo.Vars.Max
}
func (g *Gini) Lit() z.Lit {
	return g.xo.Lit()
}
func (g *Gini) Add(m z.Lit) {
	g.xo.Add(m)
}
func (g *Gini) Assume(ms ...z.Lit) {
	g.xo.Assume(ms...)
}
func (g *Gini) Solve() int {
	res := g.xo.Solve()
	return res
}
func (g *Gini) Try(dur time.Duration) int {
	return g.xo.Try(dur)
}
func (g *Gini) GoSolve() inter.Solve {
	return g.xo.GoSolve()
}
func (g *Gini) Value(m z.Lit) bool {
	return g.xo.Vars.Vals[m] == 1
}
func (g *Gini) Why(ms []z.Lit) []z.Lit {
	return g.xo.Why(ms)
}
func (g *Gini) Test(dst []z.Lit) (res int, out []z.Lit) {
	return g.xo.Test(dst)
}
func (g *Gini) Untest() int {
	return g.xo.Untest()
}
func (g *Gini) Reasons(dst []z.Lit, m z.Lit) []z.Lit {
	return g.xo.Reasons(dst, m)
}
func (g *Gini) Activate() (m z.Lit) {
	return g.xo.Activate()
}