+/* --- @mpx_udivn@ --- *
+ *
+ * Arguments: @mpw *qv, *qvl@ = storage for the quotient (may overlap
+ * dividend)
+ * @const mpw *rv, *rvl@ = dividend
+ * @mpw d@ = single-precision divisor
+ *
+ * Returns: Remainder after divison.
+ *
+ * Use: Performs a single-precision division operation.
+ */
+
+extern mpw mpx_udivn(mpw */*qv*/, mpw */*qvl*/,
+ const mpw */*rv*/, const mpw */*rvl*/, mpw /*d*/);
+
+/*----- Karatsuba multiplication algorithms -------------------------------*/
+
+/* --- @MPK_THRESH@ --- *
+ *
+ * This is the limiting length for using Karatsuba algorithms. It's best to
+ * use the simpler classical multiplication method on numbers smaller than
+ * this.
+ */
+
+#define MPK_THRESH 16
+
+/* --- @MPK_SLOP@ --- *
+ *
+ * The extra number of words required as scratch space by the Karatsuba
+ * routines. This is a (generous) guess, since the actual amount of space
+ * required is proportional to the recursion depth.
+ */
+
+#define MPK_SLOP 64
+
+/* --- @mpx_kmul@ --- *
+ *
+ * Arguments: @mpw *dv, *dvl@ = pointer to destination buffer
+ * @const mpw *av, *avl@ = pointer to first argument
+ * @const mpw *bv, *bvl@ = pointer to second argument
+ * @mpw *sv, *svl@ = pointer to scratch workspace
+ *
+ * Returns: ---
+ *
+ * Use: Multiplies two multiprecision integers using Karatsuba's
+ * algorithm. This is rather faster than traditional long
+ * multiplication (e.g., @mpx_umul@) on large numbers, although
+ * more expensive on small ones.
+ *
+ * The destination and scratch buffers must be twice as large as
+ * the larger argument. The scratch space must be twice as
+ * large as the larger argument, plus the magic number
+ * @MPK_SLOP@.
+ */
+
+extern void mpx_kmul(mpw */*dv*/, mpw */*dvl*/,
+ const mpw */*av*/, const mpw */*avl*/,
+ const mpw */*bv*/, const mpw */*bvl*/,
+ mpw */*sv*/, mpw */*svl*/);
+
+/* --- @mpx_ksqr@ --- *
+ *
+ * Arguments: @mpw *dv, *dvl@ = pointer to destination buffer
+ * @const mpw *av, *avl@ = pointer to first argument
+ * @mpw *sv, *svl@ = pointer to scratch workspace
+ *
+ * Returns: ---
+ *
+ * Use: Squares a multiprecision integers using something similar to
+ * Karatsuba's multiplication algorithm. This is rather faster
+ * than traditional long multiplication (e.g., @mpx_umul@) on
+ * large numbers, although more expensive on small ones, and
+ * rather simpler than full-blown Karatsuba multiplication.
+ *
+ * The destination must be twice as large as the argument. The
+ * scratch space must be twice as large as the argument, plus
+ * the magic number @MPK_SLOP@.
+ */
+
+extern void mpx_ksqr(mpw */*dv*/, mpw */*dvl*/,
+ const mpw */*av*/, const mpw */*avl*/,
+ mpw */*sv*/, mpw */*svl*/);
+