/** Returns a * b mod m. */
    abstract long mulMod(long a, long b, long m);

    /** Returns a^2 mod m. */
    abstract long squareMod(long a, long m);

    /** Returns a^p mod m. */
    private long powMod(long a, long p, long m) {
      long res = 1;
      for (; p != 0; p >>= 1) {
        if ((p & 1) != 0) {
          res = mulMod(res, a, m);
        }
        a = squareMod(a, m);

	MULF	F0, F1, F2    // 002a21ee
	MULD.EQ	F3, F4, F5    // 035b240e
	MULF.NE	F0, F2        // 002a221e
	MULD	F3, F5        // 035b25ee
	NMULF	F0, F1, F2    // 402a21ee
	NMULF	F3, F7        // 437a27ee
	NMULD	F0, F1, F2    // 402b21ee
	NMULD	F3, F7        // 437b27ee
	MULAF	F5, F6, F7    // 057a06ee
	MULAD	F5, F6, F7    // 057b06ee
	MULSF	F5, F6, F7    // 457a06ee
	MULSD	F5, F6, F7    // 457b06ee

	MULLW	$-32769, R8           // c281ffff7fff
	MULLW   $-32769, R8, R9       // 1898c291ffff7fff
	MULLD	$-2147483648, R1      // c21080000000
	MULLD   $-2147483648, R1, R2  // b9040021c22080000000
	MULHD	R9, R8                // b90400b8b98600a9ebb9003f000ab98000b8b90900abebb8003f000ab98000b9b9e9b08a
	MULHD	R7, R2, R1            // b90400b2b98600a7ebb7003f000ab98000b2b90900abebb2003f000ab98000b7b9e9b01a

}

// Grammar for Operand:
//
// operand → multOp ( ("-" | "+") multOp )*
// multOp  → unary ( ("/" | "*" | "%") unary )*
// unary   → "-" unary | primary
// primary → Value | Variable | "(" expression ")"
//

// An Operand is a single term followed by an optional sequence of
// terms separated by +/-
type Operand struct {
	Left  *MultOp     `parser:"@@"`
	Right []*OpFactor `parser:"(@@)*"`
}

	MULHW R3, R4, R5                // 7ca41896

	MULHWU R3, R4, R5               // 7ca41816
	MULLD R3, R4                    // 7c8419d2
	MULLD R4, R4, R5                // 7ca421d2
	MULLD $20, R4                   // 1c840014
	MULLD $200000000, R4            // 641f0beb63ffc2007c9f21d2

	MULLDCC R3, R4, R5              // 7ca419d3
	MULHD R3, R4, R5                // 7ca41892
	MULHDCC R3, R4, R5              // 7ca41893

	BL	4(R4)              // ERROR "non-zero offset"
	ADDF	F0, R1, F2         // ERROR "illegal combination"
	SWI	(R0)               // ERROR "illegal combination"
	MULAD	F0, F1             // ERROR "illegal combination"
	MULAF	F0, F1             // ERROR "illegal combination"
	MULSD	F0, F1             // ERROR "illegal combination"
	MULSF	F0, F1             // ERROR "illegal combination"
	NMULAD	F0, F1             // ERROR "illegal combination"

	if err != nil {
		return err
	}
	for _, rt := range e.Right {
		err = rt.Right.aggregateRow(r, tableAlias)
		if err != nil {
			return err
		}
	}
	return nil
}

func (e *MultOp) aggregateRow(r Record, tableAlias string) error {
	err := e.Left.aggregateRow(r, tableAlias)
	if err != nil {
		return err
	}
	for _, rt := range e.Right {
		err = rt.Right.aggregateRow(r, tableAlias)

}

func (e *Operand) analyze(s *Select) (result qProp) {
	result.combine(e.Left.analyze(s))
	for _, r := range e.Right {
		result.combine(r.Right.analyze(s))
	}
	return result
}

func (e *MultOp) analyze(s *Select) (result qProp) {
	result.combine(e.Left.analyze(s))
	for _, r := range e.Right {
		result.combine(r.Right.analyze(s))
	}
	return result
}

		if rerr != nil {
			return nil, rerr
		}
		err := lval.arithOp(op, rval)
		if err != nil {
			return nil, err
		}
	}
	return lval, nil
}

func (e *MultOp) evalNode(r Record, tableAlias string) (*Value, error) {
	lval, lerr := e.Left.evalNode(r, tableAlias)
	if lerr != nil || len(e.Right) == 0 {
		return lval, lerr
	}

Expression = UnaryExpr | Expression binary_op Expression .
UnaryExpr  = PrimaryExpr | unary_op UnaryExpr .

binary_op  = "||" | "&&" | rel_op | add_op | mul_op .
rel_op     = "==" | "!=" | "<" | "<=" | ">" | ">=" .
add_op     = "+" | "-" | "|" | "^" .
mul_op     = "*" | "/" | "%" | "<<" | ">>" | "&" | "&^" .

unary_op   = "+" | "-" | "!" | "^" | "*" | "&" | "<-" .
</pre>

<p>