func (e *Engine) exp(c, a *fe12) {
	c.set(a)
	e.fp12.cyclotomicSquare(c)  
	e.fp12.mulAssign(c, a)
	e.fp12.cyclotomicSquare(c)
	e.fp12.cyclotomicSquare(c)
	e.fp12.mulAssign(c, a)
	e.fp12.cyclotomicSquare(c)
	e.fp12.cyclotomicSquare(c)
	e.fp12.cyclotomicSquare(c)
	e.fp12.mulAssign(c, a)
	e.fp12.cyclotomicSquare(c)
	e.fp12.cyclotomicSquare(c)
	e.fp12.cyclotomicSquare(c)
	e.fp12.cyclotomicSquare(c)
	e.fp12.cyclotomicSquare(c)
	e.fp12.cyclotomicSquare(c)
	e.fp12.cyclotomicSquare(c)
	e.fp12.cyclotomicSquare(c)
	e.fp12.cyclotomicSquare(c)
	e.fp12.mulAssign(c, a)
	for i := 0; i < 32; i++ {
		e.fp12.cyclotomicSquare(c)
	}
	e.fp12.mulAssign(c, a)
	for i := 0; i < 16; i++ {
		e.fp12.cyclotomicSquare(c)
	}
	fp12Conjugate(c, c)
}
exp raises element by x = -15132376222941642752
package bls12381
type pair struct {
	g1 *PointG1
	g2 *PointG2
}
func newPair(g1 *PointG1, g2 *PointG2) pair {
	return pair{g1, g2}
}
type Engine struct {
	G1   *G1
	G2   *G2
	fp12 *fp12
	fp2  *fp2
	pairingEngineTemp
	pairs []pair
}
func NewEngine() *Engine {
	fp2 := newFp2()
	fp6 := newFp6(fp2)
	fp12 := newFp12(fp6)
	g1 := NewG1()
	g2 := newG2(fp2)
	return &Engine{
		fp2:               fp2,
		fp12:              fp12,
		G1:                g1,
		G2:                g2,
		pairingEngineTemp: newEngineTemp(),
	}
}
type pairingEngineTemp struct {
	t2  [9]*fe2
	t12 [3]fe12
}
func newEngineTemp() pairingEngineTemp {
	t2 := [9]*fe2{}
	for i := 0; i < len(t2); i++ {
		t2[i] = &fe2{}
	}
	t12 := [3]fe12{}
	return pairingEngineTemp{t2, t12}
}
func (e *Engine) AddPair(g1 *PointG1, g2 *PointG2) *Engine {
	p := newPair(g1, g2)
	if !(e.G1.IsZero(p.g1) || e.G2.IsZero(p.g2)) {
		e.G1.Affine(p.g1)
		e.G2.Affine(p.g2)
		e.pairs = append(e.pairs, p)
	}
	return e
}
func (e *Engine) AddPairInv(g1 *PointG1, g2 *PointG2) *Engine {
	ng1 := e.G1.New().Set(g1)
	e.G1.Neg(ng1, g1)
	e.AddPair(ng1, g2)
	return e
}
func (e *Engine) Reset() *Engine {
	e.pairs = []pair{}
	return e
}
func (e *Engine) double(f *fe12, r *PointG2, k int) {
	fp2, t := e.fp2, e.t2
	fp2.mul(t[0], &r[0], &r[1])
	fp2.mul0(t[0], t[0], twoInv)
	fp2.square(t[1], &r[1])
	fp2.square(t[2], &r[2])
	fp2Double(t[7], t[2])
	fp2AddAssign(t[7], t[2])
	fp2.mulByB(t[3], t[7])
	fp2Double(t[4], t[3])
	fp2AddAssign(t[4], t[3])
	fp2Add(t[5], t[1], t[4])
	fp2.mul0(t[5], t[5], twoInv)
	fp2Add(t[6], &r[1], &r[2])
	fp2.squareAssign(t[6])
	fp2Add(t[7], t[2], t[1])
	fp2SubAssign(t[6], t[7])
	fp2Sub(t[8], t[3], t[1])
	fp2.square(t[7], &r[0])
	fp2Sub(t[4], t[1], t[4])
	fp2.mul(&r[0], t[4], t[0])
	fp2.square(t[2], t[3])
	fp2Double(t[3], t[2])
	fp2AddAssign(t[3], t[2])
	fp2.squareAssign(t[5])
	fp2Sub(&r[1], t[5], t[3])
	fp2.mul(&r[2], t[1], t[6])
	fp2Double(t[0], t[7])
	fp2AddAssign(t[0], t[7])
	fp2Neg(t[6], t[6])
	e.fp2.mul0Assign(t[6], &e.pairs[k].g1[1])
	e.fp2.mul0Assign(t[0], &e.pairs[k].g1[0])
	e.fp12.mul014(f, t[8], t[0], t[6])
}
func (e *Engine) add(f *fe12, r *PointG2, k int) {
	fp2, t := e.fp2, e.t2
	fp2.mul(t[0], &e.pairs[k].g2[1], &r[2])
	fp2Neg(t[0], t[0])
	fp2AddAssign(t[0], &r[1])
	fp2.mul(t[1], &e.pairs[k].g2[0], &r[2])
	fp2Neg(t[1], t[1])
	fp2AddAssign(t[1], &r[0])
	fp2.square(t[2], t[0])
	fp2.square(t[3], t[1])
	fp2.mul(t[4], t[1], t[3])
	fp2.mul(t[2], &r[2], t[2])
	fp2.mulAssign(t[3], &r[0])
	fp2Double(t[5], t[3])
	fp2Sub(t[5], t[4], t[5])
	fp2AddAssign(t[5], t[2])
	fp2.mul(&r[0], t[1], t[5])
	fp2SubAssign(t[3], t[5])
	fp2.mulAssign(t[3], t[0])
	fp2.mul(t[2], &r[1], t[4])
	fp2Sub(&r[1], t[3], t[2])
	fp2.mulAssign(&r[2], t[4])
	fp2.mul(t[2], t[1], &e.pairs[k].g2[1])
	fp2.mul(t[3], t[0], &e.pairs[k].g2[0])
	fp2SubAssign(t[3], t[2])
	fp2Neg(t[0], t[0])
	e.fp2.mul0Assign(t[1], &e.pairs[k].g1[1])
	e.fp2.mul0Assign(t[0], &e.pairs[k].g1[0])
	e.fp12.mul014(f, t[3], t[0], t[1])
}
func (e *Engine) nDoubleAdd(f *fe12, r []PointG2, n int) {
	for i := 0; i < n; i++ {
		e.fp12.squareAssign(f)
		for j := 0; j < len(e.pairs); j++ {
			e.double(f, &r[j], j)
		}
	}
	for j := 0; j < len(e.pairs); j++ {
		e.add(f, &r[j], j)
	}
}
func (e *Engine) nDouble(f *fe12, r []PointG2, n int) {
	for i := 0; i < n; i++ {
		e.fp12.squareAssign(f)
		for j := 0; j < len(e.pairs); j++ {
			e.double(f, &r[j], j)
		}
	}
}
func (e *Engine) millerLoop(f *fe12) {
	f.one()
	r := make([]PointG2, len(e.pairs))
	for i := 0; i < len(e.pairs); i++ {
		r[i].Set(e.pairs[i].g2)
	}
	for j := 0; j < len(e.pairs); j++ {
		e.double(f, &r[j], j)
	}
	for j := 0; j < len(e.pairs); j++ {
		e.add(f, &r[j], j)
	}
	e.nDoubleAdd(f, r, 2)
	e.nDoubleAdd(f, r, 3)
	e.nDoubleAdd(f, r, 9)
	e.nDoubleAdd(f, r, 32)
	e.nDouble(f, r, 16)
	fp12Conjugate(f, f)
}