mp-genie.c

     
 //! @file mp-genie.c
 //! @author J. Marcel van der Veer
 
 //! @section Copyright
 //!
 //! This file is part of Algol68G - an Algol 68 compiler-interpreter.
 //! Copyright 2001-2026 J. Marcel van der Veer [algol68g@algol68genie.nl].
 
 //! @section License
 //!
 //! This program is free software; you can redistribute it and/or modify it 
 //! under the terms of the GNU General Public License as published by the 
 //! Free Software Foundation; either version 3 of the License, or 
 //! (at your option) any later version.
 //!
 //! This program is distributed in the hope that it will be useful, but 
 //! WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
 //! or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 
 //! more details. You should have received a copy of the GNU General Public 
 //! License along with this program. If not, see [http://www.gnu.org/licenses/].
 
 //! @section Synopsis
 //!
 //! Multi-precision interpreter routines.
 
 #include "a68g.h"
 #include "a68g-genie.h"
 #include "a68g-prelude.h"
 #include "a68g-mp.h"
 
 //! brief LONG REAL long infinity
 
 void genie_infinity_mp (NODE_T *p)
 {
   int digs = DIGITS (MOID (p));
   MP_T *z = nil_mp (p, digs);
   MP_STATUS (z) = (PLUS_INF_MASK | INIT_MASK);
 }
 
 //! brief LONG REAL long minus infinity
 
 void genie_minus_infinity_mp (NODE_T *p)
 {
   int digs = DIGITS (MOID (p));
   MP_T *z = nil_mp (p, digs);
   MP_STATUS (z) = (MINUS_INF_MASK | INIT_MASK);
 }
 
 //! @brief LONG INT long max int
 
 void genie_long_max_int (NODE_T * p)
 {
   int digs = DIGITS (M_LONG_INT);
   MP_T *z = nil_mp (p, digs);
   MP_STATUS (z) = (MP_T) INIT_MASK;
   MP_EXPONENT (z) = (MP_T) (digs - 1);
   for (int k = 1; k <= digs; k++) {
     MP_DIGIT (z, k) = (MP_T) (MP_RADIX - 1);
   }
 }
 
 //! @brief LONG LONG INT long long max int
 
 void genie_long_mp_max_int (NODE_T * p)
 {
   int digs = DIGITS (M_LONG_LONG_INT);
   MP_T *z = nil_mp (p, digs);
   MP_STATUS (z) = (MP_T) INIT_MASK;
   MP_EXPONENT (z) = (MP_T) (digs - 1);
   for (int k = 1; k <= digs; k++) {
     MP_DIGIT (z, k) = (MP_T) (MP_RADIX - 1);
   }
 }
 
 //! @brief LONG REAL long max real
 
 void genie_long_max_real (NODE_T * p)
 {
   int digs = DIGITS (M_LONG_REAL);
   MP_T *z = nil_mp (p, digs);
   MP_STATUS (z) = (MP_T) INIT_MASK;
   MP_EXPONENT (z) = (MP_T) (MAX_MP_EXPONENT - 1);
   for (int k = 1; k <= digs; k++) {
     MP_DIGIT (z, k) = (MP_T) (MP_RADIX - 1);
   }
 }
 
 //! @brief LONG LONG REAL long long max real
 
 void genie_long_mp_max_real (NODE_T * p)
 {
   int digs = DIGITS (M_LONG_LONG_REAL);
   MP_T *z = nil_mp (p, digs);
   MP_STATUS (z) = (MP_T) INIT_MASK;
   MP_EXPONENT (z) = (MP_T) (MAX_MP_EXPONENT - 1);
   for (int k = 1; k <= digs; k++) {
     MP_DIGIT (z, k) = (MP_T) (MP_RADIX - 1);
   }
 }
 
 //! @brief LONG REAL min long real
 
 void genie_long_min_real (NODE_T * p)
 {
   (void) lit_mp (p, 1, -MAX_MP_EXPONENT, DIGITS (M_LONG_REAL));
 }
 
 //! @brief LONG LONG REAL min long long real
 
 void genie_long_mp_min_real (NODE_T * p)
 {
   (void) lit_mp (p, 1, -MAX_MP_EXPONENT, DIGITS (M_LONG_LONG_REAL));
 }
 
 //! @brief LONG REAL small long real
 
 void genie_long_small_real (NODE_T * p)
 {
   int digs = DIGITS (M_LONG_REAL);
   (void) lit_mp (p, 1, 1 - digs, digs);
 }
 
 //! @brief LONG LONG REAL small long long real
 
 void genie_long_mp_small_real (NODE_T * p)
 {
   int digs = DIGITS (M_LONG_LONG_REAL);
   (void) lit_mp (p, 1, 1 - digs, digs);
 }
 
 //! @brief OP LENG = (INT) LONG INT
 
 void genie_lengthen_int_to_mp (NODE_T * p)
 {
   int digs = DIGITS (M_LONG_INT);
   A68G_INT k;
   POP_OBJECT (p, &k, A68G_INT);
   MP_T *z = nil_mp (p, digs);
   (void) int_to_mp (p, z, VALUE (&k), digs);
   MP_STATUS (z) = (MP_T) INIT_MASK;
 }
 
 //! @brief OP SHORTEN = (LONG INT) INT
 
 void genie_shorten_mp_to_int (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   int digs = DIGITS (mode), size = SIZE (mode);
   DECREMENT_STACK_POINTER (p, size);
   MP_T *z = (MP_T *) STACK_TOP;
   MP_STATUS (z) = (MP_T) INIT_MASK;
   PUSH_VALUE (p, mp_to_int (p, z, digs), A68G_INT);
 }
 
 //! @brief OP LENG = (REAL) LONG REAL
 
 void genie_lengthen_real_to_mp (NODE_T * p)
 {
   int digs = DIGITS (M_LONG_REAL);
   A68G_REAL x;
   POP_OBJECT (p, &x, A68G_REAL);
   MP_T *z = nil_mp (p, digs);
   (void) real_to_mp (p, z, VALUE (&x), digs);
   MP_STATUS (z) = (MP_T) INIT_MASK;
 }
 
 //! @brief OP SHORTEN = (LONG REAL) REAL
 
 void genie_shorten_mp_to_real (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   int digs = DIGITS (mode), size = SIZE (mode);
   DECREMENT_STACK_POINTER (p, size);
   MP_T *z = (MP_T *) STACK_TOP;
   MP_STATUS (z) = (MP_T) INIT_MASK;
   PUSH_VALUE (p, mp_to_real (p, z, digs), A68G_REAL);
 }
 
 //! @brief OP ENTIER = (LONG REAL) LONG INT
 
 void genie_entier_mp (NODE_T * p)
 {
   int digs = DIGITS (LHS_MODE (p)), size = SIZE (LHS_MODE (p));
   ADDR_T pop_sp = A68G_SP;
   MP_T *z = (MP_T *) STACK_OFFSET (-size);
   (void) entier_mp (p, z, z, digs);
   A68G_SP = pop_sp;
 }
 
 //! @brief OP CEIL = (LONG REAL) LONG INT
 
 void genie_ceil_mp (NODE_T * p)
 {
   int digs = DIGITS (LHS_MODE (p)), size = SIZE (LHS_MODE (p));
   ADDR_T pop_sp = A68G_SP;
   MP_T *z = (MP_T *) STACK_OFFSET (-size);
   (void) ceil_mp (p, z, z, digs);
   A68G_SP = pop_sp;
 }
 
 //! @brief OP TRUNC = (LONG REAL) LONG INT
 
 void genie_trunc_mp (NODE_T * p)
 {
   int digs = DIGITS (LHS_MODE (p)), size = SIZE (LHS_MODE (p));
   ADDR_T pop_sp = A68G_SP;
   MP_T *z = (MP_T *) STACK_OFFSET (-size);
   (void) trunc_mp (p, z, z, digs);
   A68G_SP = pop_sp;
 }
 
 //! @brief OP FRAC = (LONG REAL) LONG INT
 
 void genie_frac_mp (NODE_T * p)
 {
   int digs = DIGITS (LHS_MODE (p)), size = SIZE (LHS_MODE (p));
   ADDR_T pop_sp = A68G_SP;
   MP_T *z = (MP_T *) STACK_OFFSET (-size);
   (void) frac_mp (p, z, z, digs);
   A68G_SP = pop_sp;
 }
 
 #define C_L_FUNCTION(p, f)\
   int digs = DIGITS (MOID (p)), size = SIZE (MOID (p));\
   ADDR_T pop_sp = A68G_SP;\
   MP_T *x = (MP_T *) STACK_OFFSET (-size);\
   errno = 0;\
   PRELUDE_ERROR (f (p, x, x, digs) == NaN_MP || errno != 0, p, ERROR_INVALID_ARGUMENT, MOID (p));\
   MP_STATUS (x) = (MP_T) INIT_MASK;\
   A68G_SP = pop_sp;
 
 //! @brief PROC (LONG REAL) LONG REAL long sqrt
 
 void genie_sqrt_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, sqrt_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long curt
 
 void genie_curt_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, curt_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long exp
 
 void genie_exp_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, exp_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long erf
 
 void genie_erf_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, erf_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long inverf
 
 void genie_inverf_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, inverf_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long erfc
 
 void genie_erfc_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, erfc_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long inverfc
 
 void genie_inverfc_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, inverfc_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long gamma
 
 void genie_gamma_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, gamma_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long ln gamma
 
 void genie_lngamma_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, lngamma_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long beta
 
 void genie_beta_mp (NODE_T * p)
 {
   int digs = DIGITS (MOID (p)), size = SIZE (MOID (p));
   MP_T *b = (MP_T *) STACK_OFFSET (-size);
   MP_T *a = (MP_T *) STACK_OFFSET (- (2 * size));
   PRELUDE_ERROR (beta_mp (p, a, a, b, digs) == NaN_MP, p, ERROR_INVALID_ARGUMENT, MOID (p));
   A68G_SP -= size;
   MP_STATUS (a) = (MP_T) INIT_MASK;
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long ln beta
 
 void genie_lnbeta_mp (NODE_T * p)
 {
   int digs = DIGITS (MOID (p)), size = SIZE (MOID (p));
   MP_T *b = (MP_T *) STACK_OFFSET (-size);
   MP_T *a = (MP_T *) STACK_OFFSET (- (2 * size));
   PRELUDE_ERROR (lnbeta_mp (p, a, a, b, digs) == NaN_MP, p, ERROR_INVALID_ARGUMENT, MOID (p));
   A68G_SP -= size;
   MP_STATUS (a) = (MP_T) INIT_MASK;
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long beta
 
 void genie_beta_inc_mp (NODE_T * p)
 {
   int digs = DIGITS (MOID (p)), size = SIZE (MOID (p));
   MP_T *x = (MP_T *) STACK_OFFSET (-size);
   MP_T *t = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *s = (MP_T *) STACK_OFFSET (-3 * size);
   PRELUDE_ERROR (beta_inc_mp (p, s, s, t, x, digs) == NaN_MP, p, ERROR_INVALID_ARGUMENT, MOID (p));
   A68G_SP -= 2 * size;
   MP_STATUS (s) = (MP_T) INIT_MASK;
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long ln
 
 void genie_ln_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, ln_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long log
 
 void genie_log_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, log_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long sinh
 
 void genie_sinh_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, sinh_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long cosh
 
 void genie_cosh_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, cosh_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long tanh
 
 void genie_tanh_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, tanh_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long arcsinh
 
 void genie_asinh_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, asinh_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long arccosh
 
 void genie_acosh_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, acosh_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long arctanh
 
 void genie_atanh_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, atanh_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long sin
 
 void genie_sin_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, sin_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long cas
 
 void genie_cas_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, cas_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long cos
 
 void genie_cos_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, cos_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long tan
 
 void genie_tan_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, tan_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long arcsin
 
 void genie_asin_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, asin_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long arccos
 
 void genie_acos_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, acos_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long arctan
 
 void genie_atan_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, atan_mp);
 }
 
 //! @brief PROC (LONG REAL, LONG REAL) LONG REAL long arctan2
 
 void genie_atan2_mp (NODE_T * p)
 {
   int digs = DIGITS (MOID (p)), size = SIZE (MOID (p));
   MP_T *y = (MP_T *) STACK_OFFSET (-size);
   MP_T *x = (MP_T *) STACK_OFFSET (- (2 * size));
   PRELUDE_ERROR (atan2_mp (p, x, y, x, digs) == NaN_MP, p, ERROR_INVALID_ARGUMENT, MOID (p));
   A68G_SP -= size;
   MP_STATUS (x) = (MP_T) INIT_MASK;
 }
 
 // Arithmetic operations.
 
 //! @brief OP LENG = (LONG MODE) LONG LONG MODE
 
 void genie_lengthen_mp_to_long_mp (NODE_T * p)
 {
   DECREMENT_STACK_POINTER (p, (int) size_mp ());
   MP_T *z = (MP_T *) STACK_ADDRESS (A68G_SP);
   z = len_mp (p, z, mp_digits (), long_mp_digits ());
   MP_STATUS (z) = (MP_T) INIT_MASK;
 }
 
 //! @brief OP SHORTEN = (LONG LONG MODE) LONG MODE
 
 void genie_shorten_long_mp_to_mp (NODE_T * p)
 {
   MOID_T *m = SUB_MOID (p);
   DECREMENT_STACK_POINTER (p, (int) size_long_mp ());
   MP_T *z = empty_mp (p, mp_digits ());
   if (m == M_LONG_INT) {
     PRELUDE_ERROR (MP_EXPONENT (z) > LONG_MP_DIGITS - 1, p, ERROR_OUT_OF_BOUNDS, m);
   }
   (void) shorten_mp (p, z, mp_digits (), z, long_mp_digits ());
   MP_STATUS (z) = (MP_T) INIT_MASK;
 }
 
 //! @brief OP - = (LONG MODE) LONG MODE
 
 void genie_minus_mp (NODE_T * p)
 {
   size_t size = SIZE (LHS_MODE (p));
   MP_T *z = (MP_T *) STACK_OFFSET (-size);
   MP_STATUS (z) = (MP_T) INIT_MASK;
   MP_DIGIT (z, 1) = -MP_DIGIT (z, 1);
 }
 
 //! @brief OP ABS = (LONG MODE) LONG MODE
 
 void genie_abs_mp (NODE_T * p)
 {
   size_t size = SIZE (LHS_MODE (p));
   MP_T *z = (MP_T *) STACK_OFFSET (-size);
   MP_STATUS (z) = (MP_T) INIT_MASK;
   MP_DIGIT (z, 1) = ABS (MP_DIGIT (z, 1));
 }
 
 //! @brief OP SIGN = (LONG MODE) INT
 
 void genie_sign_mp (NODE_T * p)
 {
   size_t size = SIZE (LHS_MODE (p));
   MP_T *z = (MP_T *) STACK_OFFSET (-size);
   DECREMENT_STACK_POINTER (p, size);
   PUSH_VALUE (p, SIGN (MP_DIGIT (z, 1)), A68G_INT);
 }
 
 //! @brief OP + = (LONG MODE, LONG MODE) LONG MODE
 
 void genie_add_mp (NODE_T * p)
 {
   MOID_T *mode = RHS_MODE (p);
   int digs = DIGITS (mode), size = SIZE (mode);
   MP_T *x = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *y = (MP_T *) STACK_OFFSET (-size);
   (void) add_mp (p, x, x, y, digs);
   MP_STATUS (x) = (MP_T) INIT_MASK;
   DECREMENT_STACK_POINTER (p, size);
 }
 
 //! @brief OP - = (LONG MODE, LONG MODE) LONG MODE
 
 void genie_sub_mp (NODE_T * p)
 {
   MOID_T *mode = RHS_MODE (p);
   int digs = DIGITS (mode), size = SIZE (mode);
   MP_T *x = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *y = (MP_T *) STACK_OFFSET (-size);
   (void) sub_mp (p, x, x, y, digs);
   MP_STATUS (x) = (MP_T) INIT_MASK;
   DECREMENT_STACK_POINTER (p, size);
 }
 
 //! @brief OP * = (LONG MODE, LONG MODE) LONG MODE
 
 void genie_mul_mp (NODE_T * p)
 {
   MOID_T *mode = RHS_MODE (p);
   int digs = DIGITS (mode), size = SIZE (mode);
   MP_T *x = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *y = (MP_T *) STACK_OFFSET (-size);
   (void) mul_mp (p, x, x, y, digs);
   MP_STATUS (x) = (MP_T) INIT_MASK;
   DECREMENT_STACK_POINTER (p, size);
 }
 
 //! @brief OP / = (LONG MODE, LONG MODE) LONG MODE
 
 void genie_div_mp (NODE_T * p)
 {
   MOID_T *mode = RHS_MODE (p);
   int digs = DIGITS (mode), size = SIZE (mode);
   MP_T *x = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *y = (MP_T *) STACK_OFFSET (-size);
   PRELUDE_ERROR (div_mp (p, x, x, y, digs) == NaN_MP, p, ERROR_DIVISION_BY_ZERO, mode);
   MP_STATUS (x) = (MP_T) INIT_MASK;
   DECREMENT_STACK_POINTER (p, size);
 }
 
 //! @brief OP % = (LONG MODE, LONG MODE) LONG MODE
 
 void genie_over_mp (NODE_T * p)
 {
   MOID_T *mode = RHS_MODE (p);
   int digs = DIGITS (mode), size = SIZE (mode);
   MP_T *x = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *y = (MP_T *) STACK_OFFSET (-size);
   PRELUDE_ERROR (over_mp (p, x, x, y, digs) == NaN_MP, p, ERROR_DIVISION_BY_ZERO, mode);
   MP_STATUS (x) = (MP_T) INIT_MASK;
   DECREMENT_STACK_POINTER (p, size);
 }
 
 //! @brief OP %* = (LONG MODE, LONG MODE) LONG MODE
 
 void genie_mod_mp (NODE_T * p)
 {
   MOID_T *mode = RHS_MODE (p);
   int digs = DIGITS (mode), size = SIZE (mode);
   MP_T *x = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *y = (MP_T *) STACK_OFFSET (-size);
   PRELUDE_ERROR (mod_mp (p, x, x, y, digs) == NaN_MP, p, ERROR_DIVISION_BY_ZERO, mode);
   if (MP_DIGIT (x, 1) < 0) {
     MP_DIGIT (y, 1) = ABS (MP_DIGIT (y, 1));
     (void) add_mp (p, x, x, y, digs);
   }
   MP_STATUS (x) = (MP_T) INIT_MASK;
   DECREMENT_STACK_POINTER (p, size);
 }
 
 //! @brief OP +:= = (REF LONG MODE, LONG MODE) REF LONG MODE
 
 void genie_plusab_mp (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   genie_f_and_becomes (p, mode, genie_add_mp);
 }
 
 //! @brief OP -:= = (REF LONG MODE, LONG MODE) REF LONG MODE
 
 void genie_minusab_mp (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   genie_f_and_becomes (p, mode, genie_sub_mp);
 }
 
 //! @brief OP *:= = (REF LONG MODE, LONG MODE) REF LONG MODE
 
 void genie_timesab_mp (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   genie_f_and_becomes (p, mode, genie_mul_mp);
 }
 
 //! @brief OP /:= = (REF LONG MODE, LONG MODE) REF LONG MODE
 
 void genie_divab_mp (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   genie_f_and_becomes (p, mode, genie_div_mp);
 }
 
 //! @brief OP %:= = (REF LONG MODE, LONG MODE) REF LONG MODE
 
 void genie_overab_mp (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   genie_f_and_becomes (p, mode, genie_over_mp);
 }
 
 //! @brief OP %*:= = (REF LONG MODE, LONG MODE) REF LONG MODE
 
 void genie_modab_mp (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   genie_f_and_becomes (p, mode, genie_mod_mp);
 }
 
 // OP (LONG MODE, LONG MODE) BOOL.
 
 #define A68G_CMP_LONG(n, OP)\
 void n (NODE_T * p) {\
   MOID_T *mode = LHS_MODE (p);\
   A68G_BOOL z;\
   int digs = DIGITS (mode), size = SIZE (mode);\
   MP_T *x = (MP_T *) STACK_OFFSET (- (2 * size));\
   MP_T *y = (MP_T *) STACK_OFFSET (-size);\
   OP (p, &z, x, y, digs);\
   DECREMENT_STACK_POINTER (p, 2 * size);\
   PUSH_VALUE (p, VALUE (&z), A68G_BOOL);\
 }
 
 A68G_CMP_LONG (genie_eq_mp, eq_mp);
 A68G_CMP_LONG (genie_ne_mp, ne_mp);
 A68G_CMP_LONG (genie_lt_mp, lt_mp);
 A68G_CMP_LONG (genie_gt_mp, gt_mp);
 A68G_CMP_LONG (genie_le_mp, le_mp);
 A68G_CMP_LONG (genie_ge_mp, ge_mp);
 
 //! @brief OP ** = (LONG MODE, INT) LONG MODE
 
 void genie_pow_mp_int (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   int digs = DIGITS (mode), size = SIZE (mode);
   A68G_INT k;
   POP_OBJECT (p, &k, A68G_INT);
   MP_T *x = (MP_T *) STACK_OFFSET (-size);
   (void) pow_mp_int (p, x, x, VALUE (&k), digs);
   MP_STATUS (x) = (MP_T) INIT_MASK;
 }
 
 //! @brief OP ** = (LONG MODE, LONG MODE) LONG MODE
 
 void genie_pow_mp (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   int digs = DIGITS (mode), size = SIZE (mode);
   ADDR_T pop_sp = A68G_SP;
   MP_T *x = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *y = (MP_T *) STACK_OFFSET (-size);
   if (IS_ZERO_MP (x)) {
     if (MP_DIGIT (y, 1) < (MP_T) 0) {
       PRELUDE_ERROR (A68G_TRUE, p, ERROR_INVALID_ARGUMENT, MOID (p));
     } else if (IS_ZERO_MP (y)) {
       SET_MP_ONE (x, digs);
     }
   } else {
     (void) pow_mp (p, x, x, y, digs);
   }
   A68G_SP = pop_sp - size;
   MP_STATUS (x) = (MP_T) INIT_MASK;
 }
 
 //! @brief OP ODD = (LONG INT) BOOL
 
 void genie_odd_mp (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   int digs = DIGITS (mode), size = SIZE (mode);
   MP_T *z = (MP_T *) STACK_OFFSET (-size);
   DECREMENT_STACK_POINTER (p, size);
   if (MP_EXPONENT (z) <= (MP_T) (digs - 1)) {
     PUSH_VALUE (p, (BOOL_T) ! EVEN ((MP_INT_T) (z[(int) (2 + MP_EXPONENT (z))])), A68G_BOOL);
   } else {
     PUSH_VALUE (p, A68G_FALSE, A68G_BOOL);
   }
 }
 
 //! @brief Test whether z is a valid LONG INT.
 
 void test_mp_int_range (NODE_T * p, MP_T * z, MOID_T * m)
 {
   PRELUDE_ERROR (!check_mp_int (z, m), p, ERROR_OUT_OF_BOUNDS, m);
 }
 
 //! @brief OP + = (LONG INT, LONG INT) LONG INT
 
 void genie_add_mp_int (NODE_T * p)
 {
   MOID_T *m = RHS_MODE (p);
   int digs = DIGITS (m), size = SIZE (m);
   MP_T *x = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *y = (MP_T *) STACK_OFFSET (-size);
   (void) add_mp (p, x, x, y, digs);
   test_mp_int_range (p, x, m);
   MP_STATUS (x) = (MP_T) INIT_MASK;
   DECREMENT_STACK_POINTER (p, size);
 }
 
 //! @brief OP - = (LONG INT, LONG INT) LONG INT
 
 void genie_sub_mp_int (NODE_T * p)
 {
   MOID_T *m = RHS_MODE (p);
   int digs = DIGITS (m), size = SIZE (m);
   MP_T *x = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *y = (MP_T *) STACK_OFFSET (-size);
   (void) sub_mp (p, x, x, y, digs);
   test_mp_int_range (p, x, m);
   MP_STATUS (x) = (MP_T) INIT_MASK;
   DECREMENT_STACK_POINTER (p, size);
 }
 
 //! @brief OP * = (LONG INT, LONG INT) LONG INT
 
 void genie_mul_mp_int (NODE_T * p)
 {
   MOID_T *m = RHS_MODE (p);
   int digs = DIGITS (m), size = SIZE (m);
   MP_T *x = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *y = (MP_T *) STACK_OFFSET (-size);
   (void) mul_mp (p, x, x, y, digs);
   test_mp_int_range (p, x, m);
   MP_STATUS (x) = (MP_T) INIT_MASK;
   DECREMENT_STACK_POINTER (p, size);
 }
 
 //! @brief OP ** = (LONG MODE, INT) LONG INT
 
 void genie_pow_mp_int_int (NODE_T * p)
 {
   MOID_T *m = LHS_MODE (p);
   int digs = DIGITS (m), size = SIZE (m);
   A68G_INT k;
   POP_OBJECT (p, &k, A68G_INT);
   MP_T *x = (MP_T *) STACK_OFFSET (-size);
   (void) pow_mp_int (p, x, x, VALUE (&k), digs);
   test_mp_int_range (p, x, m);
   MP_STATUS (x) = (MP_T) INIT_MASK;
 }
 
 //! @brief OP +:= = (REF LONG INT, LONG INT) REF LONG INT
 
 void genie_plusab_mp_int (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   genie_f_and_becomes (p, mode, genie_add_mp_int);
 }
 
 //! @brief OP -:= = (REF LONG INT, LONG INT) REF LONG INT
 
 void genie_minusab_mp_int (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   genie_f_and_becomes (p, mode, genie_sub_mp_int);
 }
 
 //! @brief OP *:= = (REF LONG INT, LONG INT) REF LONG INT
 
 void genie_timesab_mp_int (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   genie_f_and_becomes (p, mode, genie_mul_mp_int);
 }
 
 //! @brief OP ROUND = (LONG REAL) LONG INT
 
 void genie_round_mp (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   int digs = DIGITS (mode), size = SIZE (mode);
   ADDR_T pop_sp = A68G_SP;
   MP_T *z = (MP_T *) STACK_OFFSET (-size);
   (void) round_mp (p, z, z, digs);
   A68G_SP = pop_sp;
 }
 
 #define C_CL_FUNCTION(p, f)\
   MOID_T *mode = MOID (p);\
   int digs = DIGITS_COMPL (mode), size = SIZE_COMPL (mode);\
   ADDR_T pop_sp = A68G_SP;\
   MP_T *im = (MP_T *) STACK_OFFSET (-size);\
   MP_T *re = (MP_T *) STACK_OFFSET (- (2 * size));\
   errno = 0;\
   (void) f(p, re, im, digs);\
   A68G_SP = pop_sp;\
   MP_STATUS (re) = (MP_T) INIT_MASK;\
   MP_STATUS (im) = (MP_T) INIT_MASK;\
   MATH_RTE (p, errno != 0, mode, NO_TEXT);\
 
 //! @brief PROC (LONG COMPLEX) LONG COMPLEX long csqrt
 
 void genie_sqrt_mp_complex (NODE_T * p)
 {
   C_CL_FUNCTION (p, csqrt_mp);
 }
 
 //! @brief PROC (LONG COMPLEX) LONG COMPLEX long cexp
 
 void genie_exp_mp_complex (NODE_T * p)
 {
   C_CL_FUNCTION (p, cexp_mp);
 }
 
 //! @brief PROC (LONG COMPLEX) LONG COMPLEX long cln
 
 void genie_ln_mp_complex (NODE_T * p)
 {
   C_CL_FUNCTION (p, cln_mp);
 }
 
 //! @brief PROC (LONG COMPLEX) LONG COMPLEX long csin
 
 void genie_sin_mp_complex (NODE_T * p)
 {
   C_CL_FUNCTION (p, csin_mp);
 }
 
 //! @brief PROC (LONG COMPLEX) LONG COMPLEX long ccos
 
 void genie_cos_mp_complex (NODE_T * p)
 {
   C_CL_FUNCTION (p, ccos_mp);
 }
 
 //! @brief PROC (LONG COMPLEX) LONG COMPLEX long ctan
 
 void genie_tan_mp_complex (NODE_T * p)
 {
   C_CL_FUNCTION (p, ctan_mp);
 }
 
 //! @brief PROC (LONG COMPLEX) LONG COMPLEX long arcsin
 
 void genie_asin_mp_complex (NODE_T * p)
 {
   C_CL_FUNCTION (p, casin_mp);
 }
 
 //! @brief PROC (LONG COMPLEX) LONG COMPLEX long carccos
 
 void genie_acos_mp_complex (NODE_T * p)
 {
   C_CL_FUNCTION (p, cacos_mp);
 }
 
 //! @brief PROC (LONG COMPLEX) LONG COMPLEX long catan
 
 void genie_atan_mp_complex (NODE_T * p)
 {
   C_CL_FUNCTION (p, catan_mp);
 }
 
 //! @brief PROC (LONG COMPLEX) LONG COMPLEX long csinh
 
 void genie_sinh_mp_complex (NODE_T * p)
 {
   C_CL_FUNCTION (p, csinh_mp);
 }
 
 //! @brief PROC (LONG COMPLEX) LONG COMPLEX long ccosh
 
 void genie_cosh_mp_complex (NODE_T * p)
 {
   C_CL_FUNCTION (p, ccosh_mp);
 }
 
 //! @brief PROC (LONG COMPLEX) LONG COMPLEX long ctanh
 
 void genie_tanh_mp_complex (NODE_T * p)
 {
   C_CL_FUNCTION (p, ctanh_mp);
 }
 
 //! @brief PROC (LONG COMPLEX) LONG COMPLEX long carcsinh
 
 void genie_asinh_mp_complex (NODE_T * p)
 {
   C_CL_FUNCTION (p, casinh_mp);
 }
 
 //! @brief PROC (LONG COMPLEX) LONG COMPLEX long carccosh
 
 void genie_acosh_mp_complex (NODE_T * p)
 {
   C_CL_FUNCTION (p, cacosh_mp);
 }
 
 //! @brief PROC (LONG COMPLEX) LONG COMPLEX long carctanh
 
 void genie_atanh_mp_complex (NODE_T * p)
 {
   C_CL_FUNCTION (p, catanh_mp);
 }
 
 //! @brief OP LENG = (COMPLEX) LONG COMPLEX
 
 void genie_lengthen_complex_to_mp_complex (NODE_T * p)
 {
   int digs = DIGITS (M_LONG_REAL);
   A68G_REAL a, b;
   POP_OBJECT (p, &b, A68G_REAL);
   POP_OBJECT (p, &a, A68G_REAL);
   MP_T *z = nil_mp (p, digs);
   (void) real_to_mp (p, z, VALUE (&a), digs);
   MP_STATUS (z) = (MP_T) INIT_MASK;
   z = nil_mp (p, digs);
   (void) real_to_mp (p, z, VALUE (&b), digs);
   MP_STATUS (z) = (MP_T) INIT_MASK;
 }
 
 //! @brief OP SHORTEN = (LONG COMPLEX) COMPLEX
 
 void genie_shorten_mp_complex_to_complex (NODE_T * p)
 {
   int digs = DIGITS (M_LONG_REAL), size = SIZE (M_LONG_REAL);
   MP_T *b = (MP_T *) STACK_OFFSET (-size);
   MP_T *a = (MP_T *) STACK_OFFSET (- (2 * size));
   DECREMENT_STACK_POINTER (p, 2 * size);
   PUSH_COMPLEX_VALUE (p, mp_to_real (p, a, digs), mp_to_real (p, b, digs));
 }
 
 //! @brief OP LENG = (LONG COMPLEX) LONG LONG COMPLEX
 
 void genie_lengthen_mp_complex_to_long_mp_complex (NODE_T * p)
 {
   int digs = DIGITS (M_LONG_REAL), size = SIZE (M_LONG_REAL);
   int gdigs = DIGITS (M_LONG_LONG_REAL), size_g = SIZE (M_LONG_LONG_REAL);
   ADDR_T pop_sp = A68G_SP;
   MP_T *a = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *b = (MP_T *) STACK_OFFSET (-size);
   MP_T *c = len_mp (p, a, digs, gdigs);
   MP_T *d = len_mp (p, b, digs, gdigs);
   (void) move_mp (a, c, gdigs);
   (void) move_mp (&a[LEN_MP (gdigs)], d, gdigs);
   A68G_SP = pop_sp;
   INCREMENT_STACK_POINTER (p, 2 * (size_g - size));
 }
 
 //! @brief OP SHORTEN = (LONG LONG COMPLEX) LONG COMPLEX
 
 void genie_shorten_long_mp_complex_to_mp_complex (NODE_T * p)
 {
   int digs = DIGITS (M_LONG_REAL), size = SIZE (M_LONG_REAL);
   int gdigs = DIGITS (M_LONG_LONG_REAL), size_g = SIZE (M_LONG_LONG_REAL);
   ADDR_T pop_sp = A68G_SP;
   MP_T *b = (MP_T *) STACK_OFFSET (-size_g);
   MP_T *a = (MP_T *) STACK_OFFSET (- (2 * size_g));
   (void) shorten_mp (p, a, digs, a, gdigs);
   (void) shorten_mp (p, &a[LEN_MP (digs)], digs, b, gdigs);
   A68G_SP = pop_sp;
   MP_STATUS (a) = (MP_T) INIT_MASK;
   MP_STATUS (&a[LEN_MP (digs)]) = (MP_T) INIT_MASK;
   DECREMENT_STACK_POINTER (p, 2 * (size_g - size));
 }
 
 //! @brief OP RE = (LONG COMPLEX) LONG REAL
 
 void genie_re_mp_complex (NODE_T * p)
 {
   size_t size = SIZE (SUB_MOID (p));
   MP_T *a = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_STATUS (a) = (MP_T) INIT_MASK;
   DECREMENT_STACK_POINTER (p, size);
 }
 
 //! @brief OP IM = (LONG COMPLEX) LONG REAL
 
 void genie_im_mp_complex (NODE_T * p)
 {
   MOID_T *mode = SUB_MOID (p);
   int digs = DIGITS (mode), size = SIZE (mode);
   MP_T *b = (MP_T *) STACK_OFFSET (-size);
   MP_T *a = (MP_T *) STACK_OFFSET (- (2 * size));
   (void) move_mp (a, b, digs);
   MP_STATUS (a) = (MP_T) INIT_MASK;
   DECREMENT_STACK_POINTER (p, size);
 }
 
 //! @brief OP - = (LONG COMPLEX) LONG COMPLEX
 
 void genie_minus_mp_complex (NODE_T * p)
 {
   size_t size = SIZE_COMPL (SUB_MOID (p));
   MP_T *b = (MP_T *) STACK_OFFSET (-size);
   MP_T *a = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_DIGIT (a, 1) = -MP_DIGIT (a, 1);
   MP_DIGIT (b, 1) = -MP_DIGIT (b, 1);
   MP_STATUS (a) = (MP_T) INIT_MASK;
   MP_STATUS (b) = (MP_T) INIT_MASK;
 }
 
 //! @brief OP CONJ = (LONG COMPLEX) LONG COMPLEX
 
 void genie_conj_mp_complex (NODE_T * p)
 {
   size_t size = SIZE_COMPL (SUB_MOID (p));
   MP_T *b = (MP_T *) STACK_OFFSET (-size);
   MP_T *a = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_DIGIT (b, 1) = -MP_DIGIT (b, 1);
   MP_STATUS (a) = (MP_T) INIT_MASK;
   MP_STATUS (b) = (MP_T) INIT_MASK;
 }
 
 //! @brief OP ABS = (LONG COMPLEX) LONG REAL
 
 void genie_abs_mp_complex (NODE_T * p)
 {
   MOID_T *mode = SUB_MOID (p);
   int digs = DIGITS (mode), size = SIZE (mode);
   ADDR_T pop_sp = A68G_SP;
   MP_T *b = (MP_T *) STACK_OFFSET (-size);
   MP_T *a = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *z = nil_mp (p, digs);
   errno = 0;
   (void) hypot_mp (p, z, a, b, digs);
   A68G_SP = pop_sp;
   DECREMENT_STACK_POINTER (p, size);
   (void) move_mp (a, z, digs);
   MP_STATUS (a) = (MP_T) INIT_MASK;
   MATH_RTE (p, errno != 0, mode, NO_TEXT);
 }
 
 //! @brief OP ARG = (LONG COMPLEX) LONG REAL
 
 void genie_arg_mp_complex (NODE_T * p)
 {
   MOID_T *mode = SUB_MOID (p);
   int digs = DIGITS (mode), size = SIZE (mode);
   ADDR_T pop_sp = A68G_SP;
   MP_T *b = (MP_T *) STACK_OFFSET (-size);
   MP_T *a = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *z = nil_mp (p, digs);
   errno = 0;
   (void) atan2_mp (p, z, a, b, digs);
   A68G_SP = pop_sp;
   DECREMENT_STACK_POINTER (p, size);
   (void) move_mp (a, z, digs);
   MP_STATUS (a) = (MP_T) INIT_MASK;
   MATH_RTE (p, errno != 0, mode, NO_TEXT);
 }
 
 //! @brief OP + = (LONG COMPLEX, LONG COMPLEX) LONG COMPLEX
 
 void genie_add_mp_complex (NODE_T * p)
 {
   MOID_T *mode = SUB_MOID (p);
   int digs = DIGITS_COMPL (mode), size = SIZE_COMPL (mode);
   ADDR_T pop_sp = A68G_SP;
   MP_T *d = (MP_T *) STACK_OFFSET (-size);
   MP_T *c = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *b = (MP_T *) STACK_OFFSET (-3 * size);
   MP_T *a = (MP_T *) STACK_OFFSET (-4 * size);
   (void) add_mp (p, b, b, d, digs);
   (void) add_mp (p, a, a, c, digs);
   MP_STATUS (a) = (MP_T) INIT_MASK;
   MP_STATUS (b) = (MP_T) INIT_MASK;
   A68G_SP = pop_sp;
   DECREMENT_STACK_POINTER (p, 2 * size);
 }
 
 //! @brief OP - = (LONG COMPLEX, LONG COMPLEX) LONG COMPLEX
 
 void genie_sub_mp_complex (NODE_T * p)
 {
   MOID_T *mode = SUB_MOID (p);
   int digs = DIGITS_COMPL (mode), size = SIZE_COMPL (mode);
   ADDR_T pop_sp = A68G_SP;
   MP_T *d = (MP_T *) STACK_OFFSET (-size);
   MP_T *c = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *b = (MP_T *) STACK_OFFSET (-3 * size);
   MP_T *a = (MP_T *) STACK_OFFSET (-4 * size);
   (void) sub_mp (p, b, b, d, digs);
   (void) sub_mp (p, a, a, c, digs);
   MP_STATUS (a) = (MP_T) INIT_MASK;
   MP_STATUS (b) = (MP_T) INIT_MASK;
   A68G_SP = pop_sp;
   DECREMENT_STACK_POINTER (p, 2 * size);
 }
 
 //! @brief OP * = (LONG COMPLEX, LONG COMPLEX) LONG COMPLEX
 
 void genie_mul_mp_complex (NODE_T * p)
 {
   MOID_T *mode = SUB_MOID (p);
   int digs = DIGITS_COMPL (mode), size = SIZE_COMPL (mode);
   ADDR_T pop_sp = A68G_SP;
   MP_T *d = (MP_T *) STACK_OFFSET (-size);
   MP_T *c = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *b = (MP_T *) STACK_OFFSET (-3 * size);
   MP_T *a = (MP_T *) STACK_OFFSET (-4 * size);
   (void) cmul_mp (p, a, b, c, d, digs);
   MP_STATUS (a) = (MP_T) INIT_MASK;
   MP_STATUS (b) = (MP_T) INIT_MASK;
   A68G_SP = pop_sp;
   DECREMENT_STACK_POINTER (p, 2 * size);
 }
 
 //! @brief OP / = (LONG COMPLEX, LONG COMPLEX) LONG COMPLEX
 
 void genie_div_mp_complex (NODE_T * p)
 {
   MOID_T *mode = SUB_MOID (p);
   int digs = DIGITS_COMPL (mode), size = SIZE_COMPL (mode);
   ADDR_T pop_sp = A68G_SP;
   MP_T *d = (MP_T *) STACK_OFFSET (-size);
   MP_T *c = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *b = (MP_T *) STACK_OFFSET (-3 * size);
   MP_T *a = (MP_T *) STACK_OFFSET (-4 * size);
   PRELUDE_ERROR (cdiv_mp (p, a, b, c, d, digs) == NaN_MP, p, ERROR_DIVISION_BY_ZERO, mode);
   MP_STATUS (a) = (MP_T) INIT_MASK;
   MP_STATUS (b) = (MP_T) INIT_MASK;
   A68G_SP = pop_sp;
   DECREMENT_STACK_POINTER (p, 2 * size);
 }
 
 //! @brief OP ** = (LONG COMPLEX, INT) LONG COMPLEX
 
 void genie_pow_mp_complex_int (NODE_T * p)
 {
   MOID_T *mode = SUB_MOID (p);
   int digs = DIGITS_COMPL (mode), size = SIZE_COMPL (mode);
   A68G_INT j;
   POP_OBJECT (p, &j, A68G_INT);
   ADDR_T pop_sp = A68G_SP;
   MP_T *im_x = (MP_T *) STACK_OFFSET (-size);
   MP_T *re_x = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *re_z = lit_mp (p, 1, 0, digs);
   MP_T *im_z = nil_mp (p, digs);
   MP_T *re_y = nil_mp (p, digs);
   MP_T *im_y = nil_mp (p, digs);
   (void) move_mp (re_y, re_x, digs);
   (void) move_mp (im_y, im_x, digs);
   MP_T *rea = nil_mp (p, digs);
   MP_T *acc = nil_mp (p, digs);
   int expo = 1;
   BOOL_T negative = (BOOL_T) (VALUE (&j) < 0);
   if (negative) {
     VALUE (&j) = -VALUE (&j);
   }
   while ((int) expo <= (int) (VALUE (&j))) {
     if (expo & VALUE (&j)) {
       (void) mul_mp (p, acc, im_z, im_y, digs);
       (void) mul_mp (p, rea, re_z, re_y, digs);
       (void) sub_mp (p, rea, rea, acc, digs);
       (void) mul_mp (p, acc, im_z, re_y, digs);
       (void) mul_mp (p, im_z, re_z, im_y, digs);
       (void) add_mp (p, im_z, im_z, acc, digs);
       (void) move_mp (re_z, rea, digs);
     }
     (void) mul_mp (p, acc, im_y, im_y, digs);
     (void) mul_mp (p, rea, re_y, re_y, digs);
     (void) sub_mp (p, rea, rea, acc, digs);
     (void) mul_mp (p, acc, im_y, re_y, digs);
     (void) mul_mp (p, im_y, re_y, im_y, digs);
     (void) add_mp (p, im_y, im_y, acc, digs);
     (void) move_mp (re_y, rea, digs);
     expo <<= 1;
   }
   A68G_SP = pop_sp;
   if (negative) {
     SET_MP_ONE (re_x, digs);
     SET_MP_ZERO (im_x, digs);
     INCREMENT_STACK_POINTER (p, 2 * size);
     genie_div_mp_complex (p);
   } else {
     (void) move_mp (re_x, re_z, digs);
     (void) move_mp (im_x, im_z, digs);
   }
   MP_STATUS (re_x) = (MP_T) INIT_MASK;
   MP_STATUS (im_x) = (MP_T) INIT_MASK;
 }
 
 //! @brief OP = = (LONG COMPLEX, LONG COMPLEX) BOOL
 
 void genie_eq_mp_complex (NODE_T * p)
 {
   int digs = DIGITS_COMPL (LHS_MODE (p)), size = SIZE_COMPL (LHS_MODE (p));
   ADDR_T pop_sp = A68G_SP;
   MP_T *d = (MP_T *) STACK_OFFSET (-size);
   MP_T *c = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *b = (MP_T *) STACK_OFFSET (-3 * size);
   MP_T *a = (MP_T *) STACK_OFFSET (-4 * size);
   (void) sub_mp (p, b, b, d, digs);
   (void) sub_mp (p, a, a, c, digs);
   A68G_SP = pop_sp;
   DECREMENT_STACK_POINTER (p, 4 * size);
   PUSH_VALUE (p, (BOOL_T) (MP_DIGIT (a, 1) == 0 && MP_DIGIT (b, 1) == 0), A68G_BOOL);
 }
 
 //! @brief OP /= = (LONG COMPLEX, LONG COMPLEX) BOOL
 
 void genie_ne_mp_complex (NODE_T * p)
 {
   int digs = DIGITS_COMPL (LHS_MODE (p)), size = SIZE_COMPL (LHS_MODE (p));
   ADDR_T pop_sp = A68G_SP;
   MP_T *d = (MP_T *) STACK_OFFSET (-size);
   MP_T *c = (MP_T *) STACK_OFFSET (- (2 * size));
   MP_T *b = (MP_T *) STACK_OFFSET (-3 * size);
   MP_T *a = (MP_T *) STACK_OFFSET (-4 * size);
   (void) sub_mp (p, b, b, d, digs);
   (void) sub_mp (p, a, a, c, digs);
   A68G_SP = pop_sp;
   DECREMENT_STACK_POINTER (p, 4 * size);
   PUSH_VALUE (p, (BOOL_T) (MP_DIGIT (a, 1) != 0 || MP_DIGIT (b, 1) != 0), A68G_BOOL);
 }
 
 //! @brief OP +:= = (REF LONG COMPLEX, LONG COMPLEX) REF LONG COMPLEX
 
 void genie_plusab_mp_complex (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   genie_f_and_becomes (p, mode, genie_add_mp_complex);
 }
 
 //! @brief OP -:= = (REF LONG COMPLEX, LONG COMPLEX) REF LONG COMPLEX
 
 void genie_minusab_mp_complex (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   genie_f_and_becomes (p, mode, genie_sub_mp_complex);
 }
 
 //! @brief OP *:= = (REF LONG COMPLEX, LONG COMPLEX) REF LONG COMPLEX
 
 void genie_timesab_mp_complex (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   genie_f_and_becomes (p, mode, genie_mul_mp_complex);
 }
 
 //! @brief OP /:= = (REF LONG COMPLEX, LONG COMPLEX) REF LONG COMPLEX
 
 void genie_divab_mp_complex (NODE_T * p)
 {
   MOID_T *mode = LHS_MODE (p);
   genie_f_and_becomes (p, mode, genie_div_mp_complex);
 }
 
 //! @brief PROC LONG REAL next long random
 
 void genie_long_next_random (NODE_T * p)
 {
 // This is 'real width' precision only.
   genie_next_random (p);
   genie_lengthen_real_to_mp (p);
   if (MOID (p) == M_LONG_LONG_REAL) {
     genie_lengthen_mp_to_long_mp (p);
   }
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long csc
 
 void genie_csc_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, csc_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long acsc
 
 void genie_acsc_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, acsc_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long sec
 
 void genie_sec_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, sec_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long asec
 
 void genie_asec_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, asec_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long cot
 
 void genie_cot_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, cot_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long acot
 
 void genie_acot_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, acot_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long sindg
 
 void genie_sindg_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, sindg_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long cosdg
 
 void genie_cosdg_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, cosdg_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long tandg
 
 void genie_tandg_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, tandg_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long secdg
 
 void genie_secdg_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, secdg_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long asecdg
 
 void genie_asecdg_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, asecdg_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long cscdg
 
 void genie_cscdg_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, cscdg_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long acscdg
 
 void genie_acscdg_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, acscdg_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long cotdg
 
 void genie_cotdg_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, cotdg_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long asindg
 
 void genie_asindg_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, asindg_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long acosdg
 
 void genie_acosdg_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, acosdg_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long atandg
 
 void genie_atandg_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, atandg_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long acotdg
 
 void genie_acotdg_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, acotdg_mp);
 }
 
 //! @brief PROC (LONG REAL, LONG REAL) LONG REAL long arctan2
 
 void genie_atan2dg_mp (NODE_T * p)
 {
   int digs = DIGITS (MOID (p)), size = SIZE (MOID (p));
   MP_T *y = (MP_T *) STACK_OFFSET (-size);
   MP_T *x = (MP_T *) STACK_OFFSET (- (2 * size));
   PRELUDE_ERROR (atan2dg_mp (p, x, y, x, digs) == NaN_MP, p, ERROR_INVALID_ARGUMENT, MOID (p));
   A68G_SP -= size;
   MP_STATUS (x) = (MP_T) INIT_MASK;
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long
 
 void genie_sinpi_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, sinpi_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long
 
 void genie_cospi_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, cospi_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long
 
 void genie_cotpi_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, cotpi_mp);
 }
 
 //! @brief PROC (LONG REAL) LONG REAL long
 
 void genie_tanpi_mp (NODE_T * p)
 {
   C_L_FUNCTION (p, tanpi_mp);
 }