/* This file was automatically generated by pclu.*/

#include "pclu_err.h"
#include "pclu_sys.h"


/**** BEGIN CLUSTER bigint ****/

extern errcode bigint_IB_1();
extern errcode bigint_IB_2();
extern errcode bigint_IB_3();
extern errcode bigint_IB_4();
extern errcode bigint_IB_5();
extern errcode bigint_IB_6();
extern errcode bigint_IB_7();
extern errcode bigint_IB_8();
extern errcode bigint_IB_9();
extern errcode bigint_IB_10();
extern errcode bigint_IB_11();
extern errcode bigint_IB_12();
extern errcode bigint_IB_13();
extern errcode bigint_IB_14();
extern errcode bigint_IB_15();
extern errcode intOPge();
extern errcode intOPlt();
extern errcode intOPmod();
extern errcode intOPdiv();
extern errcode intOPgt();
extern errcode arrayOPsize();
extern errcode arrayOPtop();
extern errcode intOPsub();
extern errcode intOPequal();
extern errcode intOPadd();
extern errcode intOPmul();
extern errcode arrayOPfetch();
extern errcode charOPequal();
extern errcode stringOPfetch();
extern errcode stringOPsize();
extern errcode intOPfrom_to();
extern errcode charOPlt();
extern errcode charOPgt();
extern errcode arrayOPstore();
extern errcode charOPc2i();
extern errcode bigintOPadd();
extern errcode bigintOPmul();
extern errcode bigintOPminus();
extern errcode bigintOPnew_base();
extern errcode arrayOPfill();
extern errcode bigintOPone_digit_divide();
extern errcode charOPi2c();
extern errcode arrayOPtrim();
extern errcode stringOPac2s();
extern errcode intOPfrom_to_by();
extern errcode boolOPnot();
extern errcode bigintOPaddsub();
extern errcode bigintOPmax_size();
extern errcode arrayOPpredict();
extern errcode bigintOPfetch_digit();
extern errcode arrayOPaddh();
extern errcode bigintOPclear_leads();
extern errcode intOPmax();
extern errcode bigintOPgtge();
extern errcode arrayOPindexes();
extern errcode bigintOPgt();
extern errcode bigintOPequal();
extern errcode arrayOPencode();
extern errcode arrayOPdecode();
extern errcode bigintOPmul_sub_in();
extern errcode arrayOPelements();
extern errcode bigintOPdivmodhack();
extern errcode boolOPequal();
extern errcode bigintOPsub();
extern errcode bigintOPdivmod();
extern errcode bigintOPold_base();
extern errcode intOPle();
extern errcode bigintOPdiv_one();
extern errcode bigintOPdiv_lt();
extern errcode bigintOPdiv_sub();
extern errcode arrayOPremh();
extern errcode arrayOPdebug_print();
extern OWN_req int_ownreqs;
extern struct OPS *int_ops;
extern struct REQS *array_of_t_reqs;
extern OWN_req array_ownreqs;
extern struct OPS *array_ops;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
extern struct OPS *char_ops;
struct OPS *array_of_char_table;
struct OPS *array_of_char_ops;
struct OPS *array_of_char_ops;
OWNPTR array_of_char_owns;
static int bigint_own_init = 0;
OWN_req bigint_ownreqs = {0,0};
errcode bigint_own_init_proc()
{
struct {
    errcode err;
    } locals;
    enter_own_init_proc();
        if (bigint_own_init == 0) {
        add_parm_info_type(0, int_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(array_of_int_ops));
        add_parm_info_type(0, char_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(array_of_char_ops));
        bigint_own_init = 1;
        {signal(ERR_ok);}
    ex_0: pclu_unhandled(locals.err); {signal(ERR_failure);}
        }
    }

extern struct dbg_info* dbg_info_bigintOPi2bi;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPi2bi_TRACE
int bigintOPi2bi_TRACE;
static Vlist39 owns_bigint = {0, 39,{ {0, 2, "bigint_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
, {0, 2, "bigintOPi2bi_init", &int_ops}
}
};
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPi2bi_own_init = 0;

/**** BEGIN PROCEDURE i2bi ****/

errcode bigintOPi2bi(i, ret_1)
CLUREF i;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF first;
        CLUREF i;
        } locals;
    locals.first.num = UNINIT;
    locals.i.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPi2bi;
    locals.i = i;
        if (bigintOPi2bi_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPi2bi_own_init = 1;
    }
    enter_proc(19);

  LINE(20);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals.i.num >= 0)? true : false;
    if (T_1_1.num == true) {

  LINE(21);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 134217728;
        T_2_2.num = (locals.i.num < T_2_1.num)? true : false;
        if (T_2_2.num == true) {

  LINE(22);
            {
            {
            CLUREF T_3_1;
            locals.err = arrayOPnew( &T_3_1);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = arrayOPaddh(T_3_1, locals.i);
            if (locals.err != ERR_ok) goto ex_0;
            ret_1->num = T_3_1.num;
            }
            {signal (ERR_ok);}}
            }
        else {

  LINE(24);
            {
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            CLUREF T_3_3;
            CLUREF T_3_4;
            CLUREF T_3_5;
            locals.err = arrayOPnew( &T_3_1);
            if (locals.err != ERR_ok) goto ex_0;
            T_3_2.num = 268435456;
            locals.err = intOPmod(locals.i, T_3_2, &T_3_3);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = arrayOPaddh(T_3_1, T_3_3);
            if (locals.err != ERR_ok) goto ex_0;
            T_3_4.num = 268435456;
            locals.err = intOPdiv(locals.i, T_3_4, &T_3_5);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = arrayOPaddh(T_3_1, T_3_5);
            if (locals.err != ERR_ok) goto ex_0;
            ret_1->num = T_3_1.num;
            }
            {signal (ERR_ok);}}
            }}/* end if */
        }
    else {

  LINE(27);
        {
            {CLUREF T_2_1;
            CLUREF T_2_2;
            T_2_1.num = 268435456;
            locals.err = intOPmod(locals.i, T_2_1, &T_2_2);
            if (locals.err != ERR_ok) goto ex_0;
            locals.first.num = T_2_2.num;
            }
            }

  LINE(28);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = -134217728;
        T_2_2.num = (locals.i.num >= T_2_1.num)? true : false;
        if (T_2_2.num == true) {

  LINE(29);
            {
            {
            CLUREF T_3_1;
            locals.err = arrayOPnew( &T_3_1);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = arrayOPaddh(T_3_1, locals.first);
            if (locals.err != ERR_ok) goto ex_0;
            ret_1->num = T_3_1.num;
            }
            {signal (ERR_ok);}}
            }
        else {

  LINE(31);
            {
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            CLUREF T_3_3;
            CLUREF T_3_4;
            CLUREF T_3_5;
            locals.err = arrayOPnew( &T_3_1);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = arrayOPaddh(T_3_1, locals.first);
            if (locals.err != ERR_ok) goto ex_0;
            T_3_2.num = 268435456;
            locals.err = intOPdiv(locals.i, T_3_2, &T_3_3);
            if (locals.err != ERR_ok) goto ex_0;
            T_3_4.num = 268435456;
            locals.err = intOPmod(T_3_3, T_3_4, &T_3_5);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = arrayOPaddh(T_3_1, T_3_5);
            if (locals.err != ERR_ok) goto ex_0;
            ret_1->num = T_3_1.num;
            }
            {signal (ERR_ok);}}
            }}/* end if */
        }}/* end if */
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE i2bi ****/

extern struct OPS *array_of_int_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPi2bi_actual;
static Vlist1 vals_bigintOPi2bi = {0, 1, { {0, 2, "", &array_of_int_ops}}
};
static siglist0 sigs_bigintOPi2bi = {0, 0};
static Vlist4 locals_bigintOPi2bi = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "first", &int_ops},  {0, 2, "i", &int_ops}}
};
static Vlist0 popowns_bigintOPi2bi = {0, 0};
Slist0 tformals_bigintOPi2bi = {0, 0};
Slist0 opformals_bigintOPi2bi = {0, 0};
dbg_info_bigintOPi2bi_actual dbg_info_bigintOPi2bi_data = {0, 12, 
    "bigintOPi2bi", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPi2bi, 1, 
    &vals_bigintOPi2bi, &sigs_bigintOPi2bi, &locals_bigintOPi2bi, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPi2bi = (struct dbg_info*)&dbg_info_bigintOPi2bi_data;
extern struct dbg_info* dbg_info_bigintOPbi2i;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPbi2i_TRACE
int bigintOPbi2i_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPbi2i_own_init = 0;

/**** BEGIN PROCEDURE bi2i ****/

errcode bigintOPbi2i(a, ret_1)
CLUREF a;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF at;
        CLUREF a;
        } locals;
    locals.at.num = UNINIT;
    locals.a.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPbi2i;
    locals.a = a;
        if (bigintOPbi2i_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPbi2i_own_init = 1;
    }
    enter_proc(36);

  LINE(37);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.a.array->ext_size;
    T_1_2.num = (T_1_1.num > 2)? true : false;
    if (T_1_2.num == true) {
        {
        {signal (ERR_overflow);}}
        }
        }/* end if */

  LINE(38);
    {
        {CLUREF T_1_1;
        locals.err = arrayOPtop(locals.a, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.at.num = T_1_1.num;
        }
        }

  LINE(39);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = 134217728;
    T_1_2.num = (locals.at.num >= T_1_1.num)? true : false;
    if (T_1_2.num == true) {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 268435456;
        locals.err = intOPsub(locals.at, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.at.num = T_2_2.num;
        }
        }
        }/* end if */

  LINE(40);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.a.array->ext_size;
    T_1_2.num = (T_1_1.num == 2)? true : false;
    if (T_1_2.num == true) {

  LINE(41);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        CLUREF T_3_4;
        T_3_1.num = 268435456;
        locals.err = intOPmul(locals.at, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.err = arrayOPfetch(locals.a, CLU_1, &T_3_3);
        if (locals.err != ERR_ok) goto ex_1;
        locals.err = intOPadd(T_3_2, T_3_3, &T_3_4);
        if (locals.err != ERR_ok) goto ex_1;
        locals.at.num = T_3_4.num;
        }
        goto end_1;
        ex_1:
            if (locals.err == ERR_overflow) {signal(ERR_overflow);}
            else {
                goto ex_0;}
        end_1:;
        }
        }/* end if */

  LINE(43);
    {
    {
    ret_1->num = locals.at.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE bi2i ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist4 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPbi2i_actual;
static Vlist1 vals_bigintOPbi2i = {0, 1, { {0, 2, "", &int_ops}}
};
static sig_desc0 sig_bigintOPbi2i_1 = {0, 3, "overflow", {0, 0
}};
static siglist1 sigs_bigintOPbi2i = {0, 1, (sig_desc*)&sig_bigintOPbi2i_1};
static Vlist4 locals_bigintOPbi2i = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "at", &int_ops},  {0, 2, "a", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPbi2i = {0, 0};
Slist0 tformals_bigintOPbi2i = {0, 0};
Slist0 opformals_bigintOPbi2i = {0, 0};
dbg_info_bigintOPbi2i_actual dbg_info_bigintOPbi2i_data = {0, 12, 
    "bigintOPbi2i", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPbi2i, 1, 
    &vals_bigintOPbi2i, &sigs_bigintOPbi2i, &locals_bigintOPbi2i, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPbi2i = (struct dbg_info*)&dbg_info_bigintOPbi2i_data;
extern struct dbg_info* dbg_info_bigintOPparse;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPparse_TRACE
int bigintOPparse_TRACE;
extern errcode bigintOPparse_IB_1();
extern OWN_req char_ownreqs;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPparse_own_init = 0;

/**** BEGIN PROCEDURE parse ****/

errcode bigintOPparse(a, ret_1)
CLUREF a;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF neg;
        CLUREF i;
        CLUREF psum;
        CLUREF ten;
        CLUREF digit;
        CLUREF j;
        CLUREF nc;
        CLUREF a;
        } locals;
    locals.neg.num = UNINIT;
    locals.i.num = UNINIT;
    locals.psum.num = UNINIT;
    locals.ten.num = UNINIT;
    locals.digit.num = UNINIT;
    locals.j.num = UNINIT;
    locals.nc.num = UNINIT;
    locals.a.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPparse;
    locals.a = a;
        if (bigintOPparse_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPparse_own_init = 1;
    }
    enter_proc(46);

  LINE(49);
    locals.neg.num = UNINIT;

  LINE(50);
    locals.i.num = UNINIT;

  LINE(51);
    {
    CLUREF T_2_1;
    CLUREF T_2_2;
    CLUREF T_2_3;
    locals.err = stringOPfetch(locals.a, CLU_1, &T_2_1);
    if (locals.err != ERR_ok) goto ex_1;
    T_2_2.ch = '-';
    T_2_3.num = (T_2_1.ch == T_2_2.ch)? true : false;
    if (T_2_3.num == true) {

  LINE(52);
        {
        locals.neg.tf = true;
        }
        {
        locals.i.num = 2;
        }

  LINE(53);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        locals.err = stringOPsize(locals.a, &T_3_1);
        if (locals.err != ERR_ok) goto ex_1;
        T_3_2.num = (T_3_1.num == 1)? true : false;
        if (T_3_2.num == true) {
            {
            {signal (ERR_bad_format);}}
            }
            }/* end if */
        }
    else {

  LINE(55);
        {
        locals.neg.tf = false;
        }
        {
        locals.i.num = 1;
        }
        }}/* end if */
        goto end_1;
        ex_1:
            if ((locals.err == ERR_bounds)) {

  LINE(56);
                {
                {signal (ERR_bad_format);}}
            }
            else {
                goto ex_0;
            }
        end_1:;

  LINE(57);
    {
        {CLUREF T_1_1;
        locals.err = arrayOPnew( &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = arrayOPaddh(T_1_1, CLU_0);
        if (locals.err != ERR_ok) goto ex_0;
        locals.psum.num = T_1_1.num;
        }
        }

  LINE(58);
    {
        {CLUREF T_1_1;
        locals.err = arrayOPnew( &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = arrayOPaddh(T_1_1, CLU_10);
        if (locals.err != ERR_ok) goto ex_0;
        locals.ten.num = T_1_1.num;
        }
        }

  LINE(59);
    {
        {CLUREF T_1_1;
        locals.err = arrayOPnew( &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = arrayOPaddh(T_1_1, CLU_0);
        if (locals.err != ERR_ok) goto ex_0;
        locals.digit.num = T_1_1.num;
        }
        }

  LINE(60);
    {
        CLUREF T_1_1;
        locals.err = stringOPsize(locals.a, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPfrom_to(locals.i, T_1_1, bigintOPparse_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        ret_1->num = elist[0].num;
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(66);
    {
    if (locals.neg.num == true) {
        {
        CLUREF T_2_1;
        locals.err = bigintOPminus(locals.psum, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.psum.num = T_2_1.num;
        }
        }
        }/* end if */

  LINE(67);
    {
    {
    ret_1->num = locals.psum.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE parse ****/

extern struct OPS *bigint_ops;
extern struct OPS *bool_ops;
extern struct OPS *string_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist10 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPparse_actual;
static Vlist1 vals_bigintOPparse = {0, 1, { {0, 2, "", &bigint_ops}}
};
static sig_desc0 sig_bigintOPparse_1 = {0, 3, "bad_format", {0, 0
}};
static siglist1 sigs_bigintOPparse = {0, 1, (sig_desc*)&sig_bigintOPparse_1};
static Vlist10 locals_bigintOPparse = {0, 10,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "neg", &bool_ops},  {0, 2, "i", &int_ops},  {0, 2, "psum", &bigint_ops},  {0, 2, "ten", &bigint_ops},  {0, 2, "digit", &bigint_ops},  {0, 2, "j", &int_ops},  {0, 2, "nc", &char_ops},  {0, 2, "a", &string_ops}}
};
static Vlist0 popowns_bigintOPparse = {0, 0};
Slist0 tformals_bigintOPparse = {0, 0};
Slist0 opformals_bigintOPparse = {0, 0};
dbg_info_bigintOPparse_actual dbg_info_bigintOPparse_data = {0, 12, 
    "bigintOPparse", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPparse, 1, 
    &vals_bigintOPparse, &sigs_bigintOPparse, &locals_bigintOPparse, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPparse = (struct dbg_info*)&dbg_info_bigintOPparse_data;

/**** BEGIN ITERATOR BODIES for parse ****/

errcode bigintOPparse_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF neg;
    CLUREF i;
    CLUREF psum;
    CLUREF ten;
    CLUREF digit;
    CLUREF j;
    CLUREF nc;
    CLUREF a;
    } *locals;
{
    locals->j.num = iv_1.num;
    enter_iter_body_proc(61);

  FB_LINE(61);
    {
        {CLUREF T_1_1;
        locals->err = stringOPfetch(locals->a, locals->j, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->nc.num = T_1_1.num;
        }
        }

  FB_LINE(62);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    CLUREF T_1_5;
    T_1_2.ch = '0';
    locals->err = charOPlt(locals->nc, T_1_2, &T_1_3);
    if (locals->err != ERR_ok) goto ex_0;
    T_1_1.num = T_1_3.num;
    if (!T_1_3.num) {
        T_1_4.ch = '9';
        locals->err = charOPgt(locals->nc, T_1_4, &T_1_5);
        if (locals->err != ERR_ok) goto ex_0;
        T_1_1.num = T_1_5.num;
    }
    if (T_1_1.num == true) {
        {
        *iecode = ERR_bad_format;
        {signal(ERR_iterbodysignal);}
        }
        }
        }/* end if */

  FB_LINE(63);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = (int)(locals->nc.ch & 0xff);
    locals->err = intOPsub(T_1_1, CLU_48, &T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    locals->err = arrayOPstore(locals->digit, CLU_1, T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    }

  FB_LINE(64);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    locals->err = bigintOPmul(locals->psum, locals->ten, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->err = bigintOPadd(T_1_1, locals->digit, &T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    locals->psum.num = T_1_2.num;
    }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end bigintOPparse_IB_1 */

/**** END ITERATOR BODIES for parse ****/

extern struct dbg_info* dbg_info_bigintOPunparse;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPunparse_TRACE
int bigintOPunparse_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS *array_of_char_table;
struct OPS *array_of_char_ops;
struct OPS *array_of_char_ops;
OWNPTR array_of_char_owns;
static int bigintOPunparse_own_init = 0;

/**** BEGIN PROCEDURE unparse ****/

errcode bigintOPunparse(r, ret_1)
CLUREF r;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF neg;
        CLUREF rnb;
        CLUREF cbsiz;
        CLUREF cbptr;
        CLUREF cbuff;
        CLUREF non_zero;
        CLUREF rem;
        CLUREF r;
        } locals;
    locals.neg.num = UNINIT;
    locals.rnb.num = UNINIT;
    locals.cbsiz.num = UNINIT;
    locals.cbptr.num = UNINIT;
    locals.cbuff.num = UNINIT;
    locals.non_zero.num = UNINIT;
    locals.rem.num = UNINIT;
    locals.r.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPunparse;
    locals.r = r;
        if (bigintOPunparse_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPunparse_own_init = 1;
    }
    enter_proc(70);

  LINE(73);
    locals.neg.num = UNINIT;

  LINE(74);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    locals.err = arrayOPtop(locals.r, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_2.num = 134217728;
    T_1_3.num = (T_1_1.num < T_1_2.num)? true : false;
    if (T_1_3.num == true) {

  LINE(75);
        {
        locals.neg.tf = false;
        }
        }
    else {

  LINE(77);
        {
        CLUREF T_2_1;
        locals.err = bigintOPminus(locals.r, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.r.num = T_2_1.num;
        }

  LINE(78);
        {
        locals.neg.tf = true;
        }
        }}/* end if */

  LINE(80);
    {
        {CLUREF T_1_1;
        locals.err = bigintOPnew_base(locals.r, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.rnb.num = T_1_1.num;
        }
        }

  LINE(81);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        T_1_1.num = locals.rnb.array->ext_size;
        locals.err = intOPmul(T_1_1, CLU_5, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.cbsiz.num = T_1_2.num;
        }
        }

  LINE(82);
    {
        {locals.cbptr.num = locals.cbsiz.num;
        }
        }

  LINE(83);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        T_1_1.ch = ' ';
        locals.err = arrayOPfill(CLU_1, locals.cbsiz, T_1_1, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.cbuff.num = T_1_2.num;
        }
        }

  LINE(84);
    {
        {locals.non_zero.tf = true;
        }
        }

  LINE(85);
    for (;;) {
        if (locals.non_zero.num != true) { break; }

  LINE(86);
        locals.rem.num = UNINIT;

  LINE(87);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        locals.err = bigintOPone_digit_divide(locals.rnb, CLU_10, &T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.non_zero.num = T_2_1.num;
        locals.rem.num = T_2_2.num;
        }

  LINE(88);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        locals.err = intOPadd(CLU_48, locals.rem, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = charOPi2c(T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = arrayOPstore(locals.cbuff, locals.cbptr, T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(89);
        {
        CLUREF T_2_1;
        locals.err = intOPsub(locals.cbptr, CLU_1, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.cbptr.num = T_2_1.num;
        }
        }
        end_while_1:;

  LINE(91);
    {
    if (locals.neg.num == true) {

  LINE(92);
        {
        CLUREF T_2_1;
        T_2_1.ch = '-';
        locals.err = arrayOPstore(locals.cbuff, locals.cbptr, T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(93);
        {
        CLUREF T_2_1;
        locals.err = intOPsub(locals.cbptr, CLU_1, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.cbptr.num = T_2_1.num;
        }
        }
        }/* end if */

  LINE(95);
    {
    CLUREF T_1_1;
    locals.err = intOPadd(locals.cbptr, CLU_1, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = arrayOPtrim(locals.cbuff, T_1_1, locals.cbsiz);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(96);
    {
    {
    CLUREF T_1_1;
    locals.err = stringOPac2s(locals.cbuff, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_1.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE unparse ****/

extern struct OPS *array_of_char_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist10 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPunparse_actual;
static Vlist1 vals_bigintOPunparse = {0, 1, { {0, 2, "", &string_ops}}
};
static siglist0 sigs_bigintOPunparse = {0, 0};
static Vlist10 locals_bigintOPunparse = {0, 10,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "neg", &bool_ops},  {0, 2, "rnb", &array_of_int_ops},  {0, 2, "cbsiz", &int_ops},  {0, 2, "cbptr", &int_ops},  {0, 2, "cbuff", &array_of_char_ops},  {0, 2, "non_zero", &bool_ops},  {0, 2, "rem", &int_ops},  {0, 2, "r", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPunparse = {0, 0};
Slist0 tformals_bigintOPunparse = {0, 0};
Slist0 opformals_bigintOPunparse = {0, 0};
dbg_info_bigintOPunparse_actual dbg_info_bigintOPunparse_data = {0, 12, 
    "bigintOPunparse", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPunparse, 1, 
    &vals_bigintOPunparse, &sigs_bigintOPunparse, &locals_bigintOPunparse, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPunparse = (struct dbg_info*)&dbg_info_bigintOPunparse_data;
extern struct dbg_info* dbg_info_bigintOPone_digit_divide;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPone_digit_divide_TRACE
int bigintOPone_digit_divide_TRACE;
extern errcode bigintOPone_digit_divide_IB_1();
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPone_digit_divide_own_init = 0;

/**** BEGIN PROCEDURE one_digit_divide ****/

errcode bigintOPone_digit_divide(rnb, d, ret_1, ret_2)
CLUREF rnb;
CLUREF d;
CLUREF *ret_1;
CLUREF *ret_2;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF non_zero;
        CLUREF rem;
        CLUREF i;
        CLUREF rv;
        CLUREF nrv;
        CLUREF rnb;
        CLUREF d;
        } locals;
    locals.non_zero.num = UNINIT;
    locals.rem.num = UNINIT;
    locals.i.num = UNINIT;
    locals.rv.num = UNINIT;
    locals.nrv.num = UNINIT;
    locals.rnb.num = UNINIT;
    locals.d.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPone_digit_divide;
    locals.rnb = rnb;
    locals.d = d;
        if (bigintOPone_digit_divide_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPone_digit_divide_own_init = 1;
    }
    enter_proc(100);

  LINE(101);
    {
        {locals.non_zero.tf = false;
        }
        }

  LINE(102);
    {
        {locals.rem.num = 0;
        }
        }

  LINE(103);
    {
        CLUREF T_1_1;
        CLUREF T_1_2;
        T_1_1.num = locals.rnb.array->ext_size;
        T_1_2.num = -1;
        locals.err = intOPfrom_to_by(T_1_1, CLU_1, T_1_2, bigintOPone_digit_divide_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        ret_1->num = elist[0].num;
        ret_2->num = elist[1].num;
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(110);
    {
    {
    ret_1->num = locals.non_zero.num;
    }
    {
    ret_2->num = locals.rem.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE one_digit_divide ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist2 *vals;
    siglist0 *sigs;
    Vlist9 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPone_digit_divide_actual;
static Vlist2 vals_bigintOPone_digit_divide = {0, 2, { {0, 2, "", &bool_ops},  {0, 2, "", &int_ops}}
};
static siglist0 sigs_bigintOPone_digit_divide = {0, 0};
static Vlist9 locals_bigintOPone_digit_divide = {0, 9,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "non_zero", &bool_ops},  {0, 2, "rem", &int_ops},  {0, 2, "i", &int_ops},  {0, 2, "rv", &int_ops},  {0, 2, "nrv", &int_ops},  {0, 2, "rnb", &array_of_int_ops},  {0, 2, "d", &int_ops}}
};
static Vlist0 popowns_bigintOPone_digit_divide = {0, 0};
Slist0 tformals_bigintOPone_digit_divide = {0, 0};
Slist0 opformals_bigintOPone_digit_divide = {0, 0};
dbg_info_bigintOPone_digit_divide_actual dbg_info_bigintOPone_digit_divide_data = {0, 12, 
    "bigintOPone_digit_divide", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPone_digit_divide, 2, 
    &vals_bigintOPone_digit_divide, &sigs_bigintOPone_digit_divide, &locals_bigintOPone_digit_divide, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPone_digit_divide = (struct dbg_info*)&dbg_info_bigintOPone_digit_divide_data;

/**** BEGIN ITERATOR BODIES for one_digit_divide ****/

errcode bigintOPone_digit_divide_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF non_zero;
    CLUREF rem;
    CLUREF i;
    CLUREF rv;
    CLUREF nrv;
    CLUREF rnb;
    CLUREF d;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(104);

  FB_LINE(104);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        T_1_1.num = 16384;
        locals->err = intOPmul(locals->rem, T_1_1, &T_1_2);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = arrayOPfetch(locals->rnb, locals->i, &T_1_3);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = intOPadd(T_1_2, T_1_3, &T_1_4);
        if (locals->err != ERR_ok) goto ex_0;
        locals->rv.num = T_1_4.num;
        }
        }

  FB_LINE(105);
    {
        {CLUREF T_1_1;
        locals->err = intOPdiv(locals->rv, locals->d, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->nrv.num = T_1_1.num;
        }
        }

  FB_LINE(106);
    {
    CLUREF T_1_1;
    locals->err = intOPmod(locals->rv, locals->d, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->rem.num = T_1_1.num;
    }

  FB_LINE(107);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = (locals->nrv.num == 0)? true : false;
    T_1_2.num = T_1_1.num ^ 1;
    if (T_1_2.num == true) {
        {
        locals->non_zero.tf = true;
        }
        }
        }/* end if */

  FB_LINE(108);
    {
    locals->err = arrayOPstore(locals->rnb, locals->i, locals->nrv);
    if (locals->err != ERR_ok) goto ex_0;
    }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end bigintOPone_digit_divide_IB_1 */

/**** END ITERATOR BODIES for one_digit_divide ****/

extern struct dbg_info* dbg_info_bigintOPadd;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPadd_TRACE
int bigintOPadd_TRACE;
extern OWN_req bigint_ownreqs;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPadd_own_init = 0;

/**** BEGIN PROCEDURE add ****/

errcode bigintOPadd(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPadd;
    locals.a = a;
    locals.b = b;
        if (bigintOPadd_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPadd_own_init = 1;
    }
    enter_proc(114);

  LINE(115);
    {
    {
    CLUREF T_1_1;
    locals.err = bigintOPaddsub(locals.a, locals.b, CLU_0, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_1.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE add ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPadd_actual;
static Vlist1 vals_bigintOPadd = {0, 1, { {0, 2, "", &array_of_int_ops}}
};
static siglist0 sigs_bigintOPadd = {0, 0};
static Vlist4 locals_bigintOPadd = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &array_of_int_ops},  {0, 2, "b", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPadd = {0, 0};
Slist0 tformals_bigintOPadd = {0, 0};
Slist0 opformals_bigintOPadd = {0, 0};
dbg_info_bigintOPadd_actual dbg_info_bigintOPadd_data = {0, 12, 
    "bigintOPadd", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPadd, 2, 
    &vals_bigintOPadd, &sigs_bigintOPadd, &locals_bigintOPadd, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPadd = (struct dbg_info*)&dbg_info_bigintOPadd_data;
extern struct dbg_info* dbg_info_bigintOPsub;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPsub_TRACE
int bigintOPsub_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPsub_own_init = 0;

/**** BEGIN PROCEDURE sub ****/

errcode bigintOPsub(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPsub;
    locals.a = a;
    locals.b = b;
        if (bigintOPsub_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPsub_own_init = 1;
    }
    enter_proc(118);

  LINE(119);
    {
    {
    CLUREF T_1_1;
    locals.err = bigintOPaddsub(locals.a, locals.b, CLU_1, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_1.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE sub ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPsub_actual;
static Vlist1 vals_bigintOPsub = {0, 1, { {0, 2, "", &array_of_int_ops}}
};
static siglist0 sigs_bigintOPsub = {0, 0};
static Vlist4 locals_bigintOPsub = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &array_of_int_ops},  {0, 2, "b", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPsub = {0, 0};
Slist0 tformals_bigintOPsub = {0, 0};
Slist0 opformals_bigintOPsub = {0, 0};
dbg_info_bigintOPsub_actual dbg_info_bigintOPsub_data = {0, 12, 
    "bigintOPsub", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPsub, 2, 
    &vals_bigintOPsub, &sigs_bigintOPsub, &locals_bigintOPsub, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPsub = (struct dbg_info*)&dbg_info_bigintOPsub_data;
extern struct dbg_info* dbg_info_bigintOPminus;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPminus_TRACE
int bigintOPminus_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPminus_own_init = 0;

/**** BEGIN PROCEDURE minus ****/

errcode bigintOPminus(a, ret_1)
CLUREF a;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF a;
        } locals;
    locals.a.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPminus;
    locals.a = a;
        if (bigintOPminus_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPminus_own_init = 1;
    }
    enter_proc(122);

  LINE(123);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    locals.err = arrayOPnew( &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = arrayOPaddh(T_1_1, CLU_0);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = bigintOPaddsub(T_1_1, locals.a, CLU_1, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_2.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE minus ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist3 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPminus_actual;
static Vlist1 vals_bigintOPminus = {0, 1, { {0, 2, "", &array_of_int_ops}}
};
static siglist0 sigs_bigintOPminus = {0, 0};
static Vlist3 locals_bigintOPminus = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPminus = {0, 0};
Slist0 tformals_bigintOPminus = {0, 0};
Slist0 opformals_bigintOPminus = {0, 0};
dbg_info_bigintOPminus_actual dbg_info_bigintOPminus_data = {0, 12, 
    "bigintOPminus", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPminus, 1, 
    &vals_bigintOPminus, &sigs_bigintOPminus, &locals_bigintOPminus, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPminus = (struct dbg_info*)&dbg_info_bigintOPminus_data;
extern struct dbg_info* dbg_info_bigintOPaddsub;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPaddsub_TRACE
int bigintOPaddsub_TRACE;
extern errcode bigintOPaddsub_IB_1();
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPaddsub_own_init = 0;

/**** BEGIN PROCEDURE addsub ****/

errcode bigintOPaddsub(a, b, neg, ret_1)
CLUREF a;
CLUREF b;
CLUREF neg;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF sz;
        CLUREF c;
        CLUREF carry;
        CLUREF fa;
        CLUREF fb;
        CLUREF psum;
        CLUREF i;
        CLUREF a;
        CLUREF b;
        CLUREF neg;
        } locals;
    locals.sz.num = UNINIT;
    locals.c.num = UNINIT;
    locals.carry.num = UNINIT;
    locals.fa.num = UNINIT;
    locals.fb.num = UNINIT;
    locals.psum.num = UNINIT;
    locals.i.num = UNINIT;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.neg.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPaddsub;
    locals.a = a;
    locals.b = b;
    locals.neg = neg;
        if (bigintOPaddsub_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPaddsub_own_init = 1;
    }
    enter_proc(127);

  LINE(128);
    {
        {CLUREF T_1_1;
        locals.err = bigintOPmax_size(locals.a, locals.b, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.sz.num = T_1_1.num;
        }
        }

  LINE(129);
    {
        {CLUREF T_1_1;
        locals.err = arrayOPpredict(CLU_1, locals.sz, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.c.num = T_1_1.num;
        }
        }

  LINE(130);
    locals.carry.num = UNINIT;

  LINE(131);
    {
    if (locals.neg.num == true) {
        {
        locals.carry.num = 1;
        }
        }
    else {
        {
        locals.carry.num = 0;
        }
        }}/* end if */

  LINE(132);
    locals.fa.num = UNINIT;
    locals.fb.num = UNINIT;
    locals.psum.num = UNINIT;

  LINE(133);
    {
        locals.err = intOPfrom_to(CLU_1, locals.sz, bigintOPaddsub_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        ret_1->num = elist[0].num;
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(147);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals.carry.num == 1)? true : false;
    if (T_1_1.num == true) {

  LINE(148);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        CLUREF T_2_5;
        CLUREF T_2_6;
        CLUREF T_2_7;
        CLUREF T_2_8;
        T_2_3.num = 134217728;
        T_2_4.num = (locals.fa.num >= T_2_3.num)? true : false;
        T_2_2.num = T_2_4.num;
        if (T_2_4.num) {
            T_2_5.num = 134217728;
            T_2_6.num = (locals.fb.num >= T_2_5.num)? true : false;
            T_2_2.num = T_2_6.num;
        }
        T_2_1.num = T_2_2.num;
        if (T_2_2.num) {
            T_2_7.num = 134217728;
            T_2_8.num = (locals.psum.num < T_2_7.num)? true : false;
            T_2_1.num = T_2_8.num;
        }
        if (T_2_1.num == true) {

  LINE(150);
            {
            CLUREF T_3_1;
            T_3_1.num = 268435455;
            locals.err = arrayOPaddh(locals.c, T_3_1);
            if (locals.err != ERR_ok) goto ex_0;
            }
            }
            }/* end if */
        }
    else {

  LINE(153);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        CLUREF T_2_5;
        CLUREF T_2_6;
        CLUREF T_2_7;
        CLUREF T_2_8;
        T_2_3.num = 134217728;
        T_2_4.num = (locals.fa.num < T_2_3.num)? true : false;
        T_2_2.num = T_2_4.num;
        if (T_2_4.num) {
            T_2_5.num = 134217728;
            T_2_6.num = (locals.fb.num < T_2_5.num)? true : false;
            T_2_2.num = T_2_6.num;
        }
        T_2_1.num = T_2_2.num;
        if (T_2_2.num) {
            T_2_7.num = 134217728;
            T_2_8.num = (locals.psum.num >= T_2_7.num)? true : false;
            T_2_1.num = T_2_8.num;
        }
        if (T_2_1.num == true) {

  LINE(155);
            {
            locals.err = arrayOPaddh(locals.c, CLU_0);
            if (locals.err != ERR_ok) goto ex_0;
            }
            }
            }/* end if */
        }}/* end if */

  LINE(158);
    {
    locals.err = bigintOPclear_leads(locals.c);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(159);
    {
    {
    ret_1->num = locals.c.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE addsub ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist12 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPaddsub_actual;
static Vlist1 vals_bigintOPaddsub = {0, 1, { {0, 2, "", &array_of_int_ops}}
};
static siglist0 sigs_bigintOPaddsub = {0, 0};
static Vlist12 locals_bigintOPaddsub = {0, 12,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "sz", &int_ops},  {0, 2, "c", &array_of_int_ops},  {0, 2, "carry", &int_ops},  {0, 2, "fa", &int_ops},  {0, 2, "fb", &int_ops},  {0, 2, "psum", &int_ops},  {0, 2, "i", &int_ops},  {0, 2, "a", &array_of_int_ops},  {0, 2, "b", &array_of_int_ops},  {0, 2, "neg", &bool_ops}}
};
static Vlist0 popowns_bigintOPaddsub = {0, 0};
Slist0 tformals_bigintOPaddsub = {0, 0};
Slist0 opformals_bigintOPaddsub = {0, 0};
dbg_info_bigintOPaddsub_actual dbg_info_bigintOPaddsub_data = {0, 12, 
    "bigintOPaddsub", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPaddsub, 3, 
    &vals_bigintOPaddsub, &sigs_bigintOPaddsub, &locals_bigintOPaddsub, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPaddsub = (struct dbg_info*)&dbg_info_bigintOPaddsub_data;

/**** BEGIN ITERATOR BODIES for addsub ****/

errcode bigintOPaddsub_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF sz;
    CLUREF c;
    CLUREF carry;
    CLUREF fa;
    CLUREF fb;
    CLUREF psum;
    CLUREF i;
    CLUREF a;
    CLUREF b;
    CLUREF neg;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(134);

  FB_LINE(134);
    {
    CLUREF T_1_1;
    locals->err = bigintOPfetch_digit(locals->a, locals->i, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->fa.num = T_1_1.num;
    }

  FB_LINE(135);
    {
    CLUREF T_1_1;
    locals->err = bigintOPfetch_digit(locals->b, locals->i, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->fb.num = T_1_1.num;
    }

  FB_LINE(136);
    {
    if (locals->neg.num == true) {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 268435455;
        locals->err = intOPsub(T_2_1, locals->fb, &T_2_2);
        if (locals->err != ERR_ok) goto ex_0;
        locals->fb.num = T_2_2.num;
        }
        }
        }/* end if */

  FB_LINE(137);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    locals->err = intOPadd(locals->fa, locals->fb, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->err = intOPadd(T_1_1, locals->carry, &T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    locals->psum.num = T_1_2.num;
    }

  FB_LINE(138);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = 268435456;
    T_1_2.num = (locals->psum.num >= T_1_1.num)? true : false;
    if (T_1_2.num == true) {

  FB_LINE(139);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 268435456;
        locals->err = intOPsub(locals->psum, T_2_1, &T_2_2);
        if (locals->err != ERR_ok) goto ex_0;
        locals->psum.num = T_2_2.num;
        }

  FB_LINE(140);
        {
        locals->carry.num = 1;
        }
        }
    else {

  FB_LINE(142);
        {
        locals->carry.num = 0;
        }
        }}/* end if */

  FB_LINE(144);
    {
    locals->err = arrayOPaddh(locals->c, locals->psum);
    if (locals->err != ERR_ok) goto ex_0;
    }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end bigintOPaddsub_IB_1 */

/**** END ITERATOR BODIES for addsub ****/

extern struct dbg_info* dbg_info_bigintOPmax_size;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPmax_size_TRACE
int bigintOPmax_size_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPmax_size_own_init = 0;

/**** BEGIN PROCEDURE max_size ****/

errcode bigintOPmax_size(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPmax_size;
    locals.a = a;
    locals.b = b;
        if (bigintOPmax_size_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPmax_size_own_init = 1;
    }
    enter_proc(163);

  LINE(164);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    T_1_1.num = locals.a.array->ext_size;
    T_1_2.num = locals.b.array->ext_size;
    locals.err = intOPmax(T_1_1, T_1_2, &T_1_3);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_3.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE max_size ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPmax_size_actual;
static Vlist1 vals_bigintOPmax_size = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_bigintOPmax_size = {0, 0};
static Vlist4 locals_bigintOPmax_size = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &array_of_int_ops},  {0, 2, "b", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPmax_size = {0, 0};
Slist0 tformals_bigintOPmax_size = {0, 0};
Slist0 opformals_bigintOPmax_size = {0, 0};
dbg_info_bigintOPmax_size_actual dbg_info_bigintOPmax_size_data = {0, 12, 
    "bigintOPmax_size", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPmax_size, 2, 
    &vals_bigintOPmax_size, &sigs_bigintOPmax_size, &locals_bigintOPmax_size, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPmax_size = (struct dbg_info*)&dbg_info_bigintOPmax_size_data;
extern struct dbg_info* dbg_info_bigintOPfetch_digit;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPfetch_digit_TRACE
int bigintOPfetch_digit_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPfetch_digit_own_init = 0;

/**** BEGIN PROCEDURE fetch_digit ****/

errcode bigintOPfetch_digit(n, i, ret_1)
CLUREF n;
CLUREF i;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF n;
        CLUREF i;
        } locals;
    locals.n.num = UNINIT;
    locals.i.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPfetch_digit;
    locals.n = n;
    locals.i = i;
        if (bigintOPfetch_digit_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPfetch_digit_own_init = 1;
    }
    enter_proc(168);

  LINE(169);
    {
    {
    CLUREF T_2_1;
    locals.err = arrayOPfetch(locals.n, locals.i, &T_2_1);
    if (locals.err != ERR_ok) goto ex_1;
    ret_1->num = T_2_1.num;
    }
    {signal (ERR_ok);}}
        goto end_1;
        ex_1:
            if ((locals.err == ERR_bounds)) {

  LINE(172);
                {
                CLUREF T_2_1;
                CLUREF T_2_2;
                CLUREF T_2_3;
                locals.err = arrayOPtop(locals.n, &T_2_1);
                if (locals.err != ERR_ok) goto ex_0;
                T_2_2.num = 134217728;
                T_2_3.num = (T_2_1.num >= T_2_2.num)? true : false;
                if (T_2_3.num == true) {

  LINE(173);
                    {
                    {
                    ret_1->num = 268435455;
                    }
                    {signal (ERR_ok);}}
                    }
                else {

  LINE(175);
                    {
                    {
                    ret_1->num = 0;
                    }
                    {signal (ERR_ok);}}
                    }}/* end if */
            }
            else {
                goto ex_0;
            }
        end_1:;
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE fetch_digit ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPfetch_digit_actual;
static Vlist1 vals_bigintOPfetch_digit = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_bigintOPfetch_digit = {0, 0};
static Vlist4 locals_bigintOPfetch_digit = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "n", &array_of_int_ops},  {0, 2, "i", &int_ops}}
};
static Vlist0 popowns_bigintOPfetch_digit = {0, 0};
Slist0 tformals_bigintOPfetch_digit = {0, 0};
Slist0 opformals_bigintOPfetch_digit = {0, 0};
dbg_info_bigintOPfetch_digit_actual dbg_info_bigintOPfetch_digit_data = {0, 12, 
    "bigintOPfetch_digit", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPfetch_digit, 2, 
    &vals_bigintOPfetch_digit, &sigs_bigintOPfetch_digit, &locals_bigintOPfetch_digit, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPfetch_digit = (struct dbg_info*)&dbg_info_bigintOPfetch_digit_data;
extern struct dbg_info* dbg_info_bigintOPgt;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPgt_TRACE
int bigintOPgt_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPgt_own_init = 0;

/**** BEGIN PROCEDURE gt ****/

errcode bigintOPgt(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPgt;
    locals.a = a;
    locals.b = b;
        if (bigintOPgt_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPgt_own_init = 1;
    }
    enter_proc(181);

  LINE(182);
    {
    {
    CLUREF T_1_1;
    locals.err = bigintOPgtge(locals.a, locals.b, CLU_0, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_1.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE gt ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPgt_actual;
static Vlist1 vals_bigintOPgt = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_bigintOPgt = {0, 0};
static Vlist4 locals_bigintOPgt = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &array_of_int_ops},  {0, 2, "b", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPgt = {0, 0};
Slist0 tformals_bigintOPgt = {0, 0};
Slist0 opformals_bigintOPgt = {0, 0};
dbg_info_bigintOPgt_actual dbg_info_bigintOPgt_data = {0, 12, 
    "bigintOPgt", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPgt, 2, 
    &vals_bigintOPgt, &sigs_bigintOPgt, &locals_bigintOPgt, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPgt = (struct dbg_info*)&dbg_info_bigintOPgt_data;
extern struct dbg_info* dbg_info_bigintOPge;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPge_TRACE
int bigintOPge_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPge_own_init = 0;

/**** BEGIN PROCEDURE ge ****/

errcode bigintOPge(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPge;
    locals.a = a;
    locals.b = b;
        if (bigintOPge_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPge_own_init = 1;
    }
    enter_proc(185);

  LINE(186);
    {
    {
    CLUREF T_1_1;
    locals.err = bigintOPgtge(locals.a, locals.b, CLU_1, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_1.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE ge ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPge_actual;
static Vlist1 vals_bigintOPge = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_bigintOPge = {0, 0};
static Vlist4 locals_bigintOPge = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &array_of_int_ops},  {0, 2, "b", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPge = {0, 0};
Slist0 tformals_bigintOPge = {0, 0};
Slist0 opformals_bigintOPge = {0, 0};
dbg_info_bigintOPge_actual dbg_info_bigintOPge_data = {0, 12, 
    "bigintOPge", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPge, 2, 
    &vals_bigintOPge, &sigs_bigintOPge, &locals_bigintOPge, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPge = (struct dbg_info*)&dbg_info_bigintOPge_data;
extern struct dbg_info* dbg_info_bigintOPlt;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPlt_TRACE
int bigintOPlt_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPlt_own_init = 0;

/**** BEGIN PROCEDURE lt ****/

errcode bigintOPlt(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPlt;
    locals.a = a;
    locals.b = b;
        if (bigintOPlt_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPlt_own_init = 1;
    }
    enter_proc(189);

  LINE(190);
    {
    {
    CLUREF T_1_1;
    locals.err = bigintOPgtge(locals.b, locals.a, CLU_0, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_1.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE lt ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPlt_actual;
static Vlist1 vals_bigintOPlt = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_bigintOPlt = {0, 0};
static Vlist4 locals_bigintOPlt = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &array_of_int_ops},  {0, 2, "b", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPlt = {0, 0};
Slist0 tformals_bigintOPlt = {0, 0};
Slist0 opformals_bigintOPlt = {0, 0};
dbg_info_bigintOPlt_actual dbg_info_bigintOPlt_data = {0, 12, 
    "bigintOPlt", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPlt, 2, 
    &vals_bigintOPlt, &sigs_bigintOPlt, &locals_bigintOPlt, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPlt = (struct dbg_info*)&dbg_info_bigintOPlt_data;
extern struct dbg_info* dbg_info_bigintOPle;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPle_TRACE
int bigintOPle_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPle_own_init = 0;

/**** BEGIN PROCEDURE le ****/

errcode bigintOPle(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPle;
    locals.a = a;
    locals.b = b;
        if (bigintOPle_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPle_own_init = 1;
    }
    enter_proc(193);

  LINE(194);
    {
    {
    CLUREF T_1_1;
    locals.err = bigintOPgtge(locals.b, locals.a, CLU_1, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_1.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE le ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPle_actual;
static Vlist1 vals_bigintOPle = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_bigintOPle = {0, 0};
static Vlist4 locals_bigintOPle = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &array_of_int_ops},  {0, 2, "b", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPle = {0, 0};
Slist0 tformals_bigintOPle = {0, 0};
Slist0 opformals_bigintOPle = {0, 0};
dbg_info_bigintOPle_actual dbg_info_bigintOPle_data = {0, 12, 
    "bigintOPle", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPle, 2, 
    &vals_bigintOPle, &sigs_bigintOPle, &locals_bigintOPle, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPle = (struct dbg_info*)&dbg_info_bigintOPle_data;
extern struct dbg_info* dbg_info_bigintOPequal;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPequal_TRACE
int bigintOPequal_TRACE;
extern errcode bigintOPequal_IB_1();
extern OWN_req bool_ownreqs;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPequal_own_init = 0;

/**** BEGIN PROCEDURE equal ****/

errcode bigintOPequal(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF i;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.i.num = UNINIT;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPequal;
    locals.a = a;
    locals.b = b;
        if (bigintOPequal_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPequal_own_init = 1;
    }
    enter_proc(197);

  LINE(198);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.a.array->ext_size;
    T_1_2.num = locals.b.array->ext_size;
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    T_1_4.num = T_1_3.num ^ 1;
    if (T_1_4.num == true) {
        {
        {
        ret_1->tf = false;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(199);
    {
        locals.err = arrayOPindexes(locals.a, bigintOPequal_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        ret_1->num = elist[0].num;
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(202);
    {
    {
    ret_1->tf = true;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE equal ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist5 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPequal_actual;
static Vlist1 vals_bigintOPequal = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_bigintOPequal = {0, 0};
static Vlist5 locals_bigintOPequal = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "i", &int_ops},  {0, 2, "a", &array_of_int_ops},  {0, 2, "b", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPequal = {0, 0};
Slist0 tformals_bigintOPequal = {0, 0};
Slist0 opformals_bigintOPequal = {0, 0};
dbg_info_bigintOPequal_actual dbg_info_bigintOPequal_data = {0, 12, 
    "bigintOPequal", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPequal, 2, 
    &vals_bigintOPequal, &sigs_bigintOPequal, &locals_bigintOPequal, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPequal = (struct dbg_info*)&dbg_info_bigintOPequal_data;

/**** BEGIN ITERATOR BODIES for equal ****/

errcode bigintOPequal_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF i;
    CLUREF a;
    CLUREF b;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(200);

  FB_LINE(200);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    locals->err = arrayOPfetch(locals->a, locals->i, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->err = arrayOPfetch(locals->b, locals->i, &T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    T_1_4.num = T_1_3.num ^ 1;
    if (T_1_4.num == true) {
        {
        {
        elist[0].tf = false;
        }
        *iecode = ERR_ok;
        {signal(ERR_iterbodyreturn);}
        }
        }
        }/* end if */
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end bigintOPequal_IB_1 */

/**** END ITERATOR BODIES for equal ****/

extern struct dbg_info* dbg_info_bigintOPmax;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPmax_TRACE
int bigintOPmax_TRACE;
static int bigintOPmax_own_init = 0;

/**** BEGIN PROCEDURE max ****/

errcode bigintOPmax(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPmax;
    locals.a = a;
    locals.b = b;
        if (bigintOPmax_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPmax_own_init = 1;
    }
    enter_proc(205);

  LINE(206);
    {
    CLUREF T_1_1;
    locals.err = bigintOPgt(locals.a, locals.b, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    if (T_1_1.num == true) {
        {
        {
        ret_1->num = locals.a.num;
        }
        {signal (ERR_ok);}}
        }
    else {
        {
        {
        ret_1->num = locals.b.num;
        }
        {signal (ERR_ok);}}
        }}/* end if */
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE max ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPmax_actual;
static Vlist1 vals_bigintOPmax = {0, 1, { {0, 2, "", &bigint_ops}}
};
static siglist0 sigs_bigintOPmax = {0, 0};
static Vlist4 locals_bigintOPmax = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &bigint_ops},  {0, 2, "b", &bigint_ops}}
};
static Vlist0 popowns_bigintOPmax = {0, 0};
Slist0 tformals_bigintOPmax = {0, 0};
Slist0 opformals_bigintOPmax = {0, 0};
dbg_info_bigintOPmax_actual dbg_info_bigintOPmax_data = {0, 12, 
    "bigintOPmax", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPmax, 2, 
    &vals_bigintOPmax, &sigs_bigintOPmax, &locals_bigintOPmax, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPmax = (struct dbg_info*)&dbg_info_bigintOPmax_data;
extern struct dbg_info* dbg_info_bigintOPmin;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPmin_TRACE
int bigintOPmin_TRACE;
static int bigintOPmin_own_init = 0;

/**** BEGIN PROCEDURE min ****/

errcode bigintOPmin(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPmin;
    locals.a = a;
    locals.b = b;
        if (bigintOPmin_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPmin_own_init = 1;
    }
    enter_proc(209);

  LINE(210);
    {
    CLUREF T_1_1;
    locals.err = bigintOPgt(locals.a, locals.b, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    if (T_1_1.num == true) {
        {
        {
        ret_1->num = locals.b.num;
        }
        {signal (ERR_ok);}}
        }
    else {
        {
        {
        ret_1->num = locals.a.num;
        }
        {signal (ERR_ok);}}
        }}/* end if */
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE min ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPmin_actual;
static Vlist1 vals_bigintOPmin = {0, 1, { {0, 2, "", &bigint_ops}}
};
static siglist0 sigs_bigintOPmin = {0, 0};
static Vlist4 locals_bigintOPmin = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &bigint_ops},  {0, 2, "b", &bigint_ops}}
};
static Vlist0 popowns_bigintOPmin = {0, 0};
Slist0 tformals_bigintOPmin = {0, 0};
Slist0 opformals_bigintOPmin = {0, 0};
dbg_info_bigintOPmin_actual dbg_info_bigintOPmin_data = {0, 12, 
    "bigintOPmin", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPmin, 2, 
    &vals_bigintOPmin, &sigs_bigintOPmin, &locals_bigintOPmin, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPmin = (struct dbg_info*)&dbg_info_bigintOPmin_data;
extern struct dbg_info* dbg_info_bigintOPabs;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPabs_TRACE
int bigintOPabs_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPabs_own_init = 0;

/**** BEGIN PROCEDURE abs ****/

errcode bigintOPabs(a, ret_1)
CLUREF a;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF a;
        } locals;
    locals.a.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPabs;
    locals.a = a;
        if (bigintOPabs_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPabs_own_init = 1;
    }
    enter_proc(213);

  LINE(214);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    locals.err = arrayOPtop(locals.a, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_2.num = 134217728;
    T_1_3.num = (T_1_1.num < T_1_2.num)? true : false;
    if (T_1_3.num == true) {
        {
        {
        ret_1->num = locals.a.num;
        }
        {signal (ERR_ok);}}
        }
    else {
        {
        {
        CLUREF T_2_1;
        locals.err = bigintOPminus(locals.a, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        ret_1->num = T_2_1.num;
        }
        {signal (ERR_ok);}}
        }}/* end if */
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE abs ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist3 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPabs_actual;
static Vlist1 vals_bigintOPabs = {0, 1, { {0, 2, "", &bigint_ops}}
};
static siglist0 sigs_bigintOPabs = {0, 0};
static Vlist3 locals_bigintOPabs = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &bigint_ops}}
};
static Vlist0 popowns_bigintOPabs = {0, 0};
Slist0 tformals_bigintOPabs = {0, 0};
Slist0 opformals_bigintOPabs = {0, 0};
dbg_info_bigintOPabs_actual dbg_info_bigintOPabs_data = {0, 12, 
    "bigintOPabs", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPabs, 1, 
    &vals_bigintOPabs, &sigs_bigintOPabs, &locals_bigintOPabs, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPabs = (struct dbg_info*)&dbg_info_bigintOPabs_data;
extern struct dbg_info* dbg_info_bigintOPgtge;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPgtge_TRACE
int bigintOPgtge_TRACE;
extern errcode bigintOPgtge_IB_1();
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPgtge_own_init = 0;

/**** BEGIN PROCEDURE gtge ****/

errcode bigintOPgtge(a, b, eq, ret_1)
CLUREF a;
CLUREF b;
CLUREF eq;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF i;
        CLUREF fa;
        CLUREF fb;
        CLUREF a;
        CLUREF b;
        CLUREF eq;
        } locals;
    locals.i.num = UNINIT;
    locals.fa.num = UNINIT;
    locals.fb.num = UNINIT;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.eq.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPgtge;
    locals.a = a;
    locals.b = b;
    locals.eq = eq;
        if (bigintOPgtge_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPgtge_own_init = 1;
    }
    enter_proc(218);

  LINE(219);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    locals.err = arrayOPtop(locals.a, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_2.num = 134217728;
    T_1_3.num = (T_1_1.num < T_1_2.num)? true : false;
    if (T_1_3.num == true) {

  LINE(220);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        locals.err = arrayOPtop(locals.b, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        T_2_2.num = 134217728;
        T_2_3.num = (T_2_1.num >= T_2_2.num)? true : false;
        if (T_2_3.num == true) {

  LINE(222);
            {
            {
            ret_1->tf = true;
            }
            {signal (ERR_ok);}}
            }
            }/* end if */
        }
    else {

  LINE(225);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        locals.err = arrayOPtop(locals.b, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        T_2_2.num = 134217728;
        T_2_3.num = (T_2_1.num < T_2_2.num)? true : false;
        if (T_2_3.num == true) {

  LINE(227);
            {
            {
            ret_1->tf = false;
            }
            {signal (ERR_ok);}}
            }
            }/* end if */
        }}/* end if */

  LINE(230);
    {
        CLUREF T_1_1;
        CLUREF T_1_2;
        locals.err = bigintOPmax_size(locals.a, locals.b, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        T_1_2.num = -1;
        locals.err = intOPfrom_to_by(T_1_1, CLU_1, T_1_2, bigintOPgtge_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        ret_1->num = elist[0].num;
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(236);
    {
    {
    ret_1->num = locals.eq.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE gtge ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist8 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPgtge_actual;
static Vlist1 vals_bigintOPgtge = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_bigintOPgtge = {0, 0};
static Vlist8 locals_bigintOPgtge = {0, 8,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "i", &int_ops},  {0, 2, "fa", &int_ops},  {0, 2, "fb", &int_ops},  {0, 2, "a", &array_of_int_ops},  {0, 2, "b", &array_of_int_ops},  {0, 2, "eq", &bool_ops}}
};
static Vlist0 popowns_bigintOPgtge = {0, 0};
Slist0 tformals_bigintOPgtge = {0, 0};
Slist0 opformals_bigintOPgtge = {0, 0};
dbg_info_bigintOPgtge_actual dbg_info_bigintOPgtge_data = {0, 12, 
    "bigintOPgtge", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPgtge, 3, 
    &vals_bigintOPgtge, &sigs_bigintOPgtge, &locals_bigintOPgtge, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPgtge = (struct dbg_info*)&dbg_info_bigintOPgtge_data;

/**** BEGIN ITERATOR BODIES for gtge ****/

errcode bigintOPgtge_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF i;
    CLUREF fa;
    CLUREF fb;
    CLUREF a;
    CLUREF b;
    CLUREF eq;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(231);

  FB_LINE(231);
    {
        {CLUREF T_1_1;
        locals->err = bigintOPfetch_digit(locals->a, locals->i, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->fa.num = T_1_1.num;
        }
        }

  FB_LINE(232);
    {
        {CLUREF T_1_1;
        locals->err = bigintOPfetch_digit(locals->b, locals->i, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->fb.num = T_1_1.num;
        }
        }

  FB_LINE(233);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals->fa.num > locals->fb.num)? true : false;
    if (T_1_1.num == true) {
        {
        {
        elist[0].tf = true;
        }
        *iecode = ERR_ok;
        {signal(ERR_iterbodyreturn);}
        }
        }
        }/* end if */

  FB_LINE(234);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals->fa.num < locals->fb.num)? true : false;
    if (T_1_1.num == true) {
        {
        {
        elist[0].tf = false;
        }
        *iecode = ERR_ok;
        {signal(ERR_iterbodyreturn);}
        }
        }
        }/* end if */
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end bigintOPgtge_IB_1 */

/**** END ITERATOR BODIES for gtge ****/

extern struct dbg_info* dbg_info_bigintOPsimilar;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPsimilar_TRACE
int bigintOPsimilar_TRACE;
static int bigintOPsimilar_own_init = 0;

/**** BEGIN PROCEDURE similar ****/

errcode bigintOPsimilar(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPsimilar;
    locals.a = a;
    locals.b = b;
        if (bigintOPsimilar_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPsimilar_own_init = 1;
    }
    enter_proc(240);

  LINE(241);
    {
    {
    CLUREF T_1_1;
    locals.err = bigintOPequal(locals.a, locals.b, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_1.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE similar ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPsimilar_actual;
static Vlist1 vals_bigintOPsimilar = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_bigintOPsimilar = {0, 0};
static Vlist4 locals_bigintOPsimilar = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &bigint_ops},  {0, 2, "b", &bigint_ops}}
};
static Vlist0 popowns_bigintOPsimilar = {0, 0};
Slist0 tformals_bigintOPsimilar = {0, 0};
Slist0 opformals_bigintOPsimilar = {0, 0};
dbg_info_bigintOPsimilar_actual dbg_info_bigintOPsimilar_data = {0, 12, 
    "bigintOPsimilar", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPsimilar, 2, 
    &vals_bigintOPsimilar, &sigs_bigintOPsimilar, &locals_bigintOPsimilar, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPsimilar = (struct dbg_info*)&dbg_info_bigintOPsimilar_data;
extern struct dbg_info* dbg_info_bigintOPcopy;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPcopy_TRACE
int bigintOPcopy_TRACE;

/**** BEGIN PROCEDURE copy ****/

errcode bigintOPcopy(a, ret_1)
CLUREF a;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF a;
        } locals;
    locals.a.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPcopy;
    locals.a = a;
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
    enter_proc(244);

  LINE(245);
    {
    {
    ret_1->num = locals.a.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE copy ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist3 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPcopy_actual;
static Vlist1 vals_bigintOPcopy = {0, 1, { {0, 2, "", &bigint_ops}}
};
static siglist0 sigs_bigintOPcopy = {0, 0};
static Vlist3 locals_bigintOPcopy = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &bigint_ops}}
};
static Vlist0 popowns_bigintOPcopy = {0, 0};
Slist0 tformals_bigintOPcopy = {0, 0};
Slist0 opformals_bigintOPcopy = {0, 0};
dbg_info_bigintOPcopy_actual dbg_info_bigintOPcopy_data = {0, 12, 
    "bigintOPcopy", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPcopy, 1, 
    &vals_bigintOPcopy, &sigs_bigintOPcopy, &locals_bigintOPcopy, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPcopy = (struct dbg_info*)&dbg_info_bigintOPcopy_data;
extern struct dbg_info* dbg_info_bigintOPencode;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPencode_TRACE
int bigintOPencode_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPencode_own_init = 0;

/**** BEGIN PROCEDURE encode ****/

errcode bigintOPencode(v, i)
CLUREF v;
CLUREF i;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF v;
        CLUREF i;
        } locals;
    locals.v.num = UNINIT;
    locals.i.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPencode;
    locals.v = v;
    locals.i = i;
        if (bigintOPencode_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPencode_own_init = 1;
    }
    enter_proc(248);

  LINE(249);
    {
    generic_CLU_proc.type_owns = array_of_int_ops->type_owns;
    generic_CLU_proc.proc = arrayOPencode;
    CUR_PROC_VAR.proc = &generic_CLU_proc;
    locals.err = arrayOPencode(locals.v, locals.i);
    if (locals.err != ERR_ok) goto ex_1;
    }
    goto end_1;
    ex_1:
        if (locals.err == ERR_not_possible) {signal(ERR_not_possible);}
        else {
            goto ex_0;}
    end_1:;
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE encode ****/

extern struct OPS *istream_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist1 *sigs;
    Vlist4 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPencode_actual;
static Vlist0 vals_bigintOPencode = {0, 0};
static sig_desc1 sig_bigintOPencode_1 = {0, 4, "not_possible", {0, 1
, { {0, 2, "", &string_ops}}}};
static siglist1 sigs_bigintOPencode = {0, 1, (sig_desc*)&sig_bigintOPencode_1};
static Vlist4 locals_bigintOPencode = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "v", &array_of_int_ops},  {0, 2, "i", &istream_ops}}
};
static Vlist0 popowns_bigintOPencode = {0, 0};
Slist0 tformals_bigintOPencode = {0, 0};
Slist0 opformals_bigintOPencode = {0, 0};
dbg_info_bigintOPencode_actual dbg_info_bigintOPencode_data = {0, 12, 
    "bigintOPencode", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPencode, 2, 
    &vals_bigintOPencode, &sigs_bigintOPencode, &locals_bigintOPencode, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPencode = (struct dbg_info*)&dbg_info_bigintOPencode_data;
extern struct dbg_info* dbg_info_bigintOPdecode;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPdecode_TRACE
int bigintOPdecode_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPdecode_own_init = 0;

/**** BEGIN PROCEDURE decode ****/

errcode bigintOPdecode(i, ret_1)
CLUREF i;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF i;
        } locals;
    locals.i.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPdecode;
    locals.i = i;
        if (bigintOPdecode_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPdecode_own_init = 1;
    }
    enter_proc(252);

  LINE(254);
    {
    {
    CLUREF T_2_1;
    generic_CLU_proc.type_owns = array_of_int_ops->type_owns;
    generic_CLU_proc.proc = arrayOPdecode;
    CUR_PROC_VAR.proc = &generic_CLU_proc;
    locals.err = arrayOPdecode(locals.i, &T_2_1);
    if (locals.err != ERR_ok) goto ex_1;
    ret_1->num = T_2_1.num;
    }
    {signal (ERR_ok);}}
    goto end_1;
    ex_1:
        if (locals.err == ERR_end_of_file) {signal(ERR_end_of_file);}
        else if (locals.err == ERR_not_possible) {signal(ERR_not_possible);}
        else {
            goto ex_0;}
    end_1:;
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE decode ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist2 *sigs;
    Vlist3 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPdecode_actual;
static Vlist1 vals_bigintOPdecode = {0, 1, { {0, 2, "", &array_of_int_ops}}
};
static sig_desc0 sig_bigintOPdecode_1 = {0, 3, "end_of_file", {0, 0
}};
static sig_desc1 sig_bigintOPdecode_2 = {0, 4, "not_possible", {0, 1
, { {0, 2, "", &string_ops}}}};
static siglist2 sigs_bigintOPdecode = {0, 2, (sig_desc*)&sig_bigintOPdecode_1, (sig_desc*)&sig_bigintOPdecode_2};
static Vlist3 locals_bigintOPdecode = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "i", &istream_ops}}
};
static Vlist0 popowns_bigintOPdecode = {0, 0};
Slist0 tformals_bigintOPdecode = {0, 0};
Slist0 opformals_bigintOPdecode = {0, 0};
dbg_info_bigintOPdecode_actual dbg_info_bigintOPdecode_data = {0, 12, 
    "bigintOPdecode", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPdecode, 1, 
    &vals_bigintOPdecode, &sigs_bigintOPdecode, &locals_bigintOPdecode, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPdecode = (struct dbg_info*)&dbg_info_bigintOPdecode_data;
extern struct dbg_info* dbg_info_bigintOPmul;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPmul_TRACE
int bigintOPmul_TRACE;
extern errcode bigintOPmul_IB_1();
extern errcode bigintOPmul_IB_2();
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPmul_own_init = 0;

/**** BEGIN PROCEDURE mul ****/

errcode bigintOPmul(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF c;
        CLUREF ia;
        CLUREF digalo;
        CLUREF digahi;
        CLUREF ib;
        CLUREF digblo;
        CLUREF digbhi;
        CLUREF splitd;
        CLUREF addlo;
        CLUREF addhi;
        CLUREF store_at;
        CLUREF newd;
        CLUREF add_in;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.c.num = UNINIT;
    locals.ia.num = UNINIT;
    locals.digalo.num = UNINIT;
    locals.digahi.num = UNINIT;
    locals.ib.num = UNINIT;
    locals.digblo.num = UNINIT;
    locals.digbhi.num = UNINIT;
    locals.splitd.num = UNINIT;
    locals.addlo.num = UNINIT;
    locals.addhi.num = UNINIT;
    locals.store_at.num = UNINIT;
    locals.newd.num = UNINIT;
    locals.add_in.num = UNINIT;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPmul;
    locals.a = a;
    locals.b = b;
        if (bigintOPmul_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPmul_own_init = 1;
    }
    enter_proc(258);

  LINE(259);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        T_1_1.num = locals.a.array->ext_size;
        T_1_2.num = locals.b.array->ext_size;
        locals.err = intOPadd(T_1_1, T_1_2, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = arrayOPfill(CLU_1, T_1_3, CLU_0, &T_1_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.c.num = T_1_4.num;
        }
        }

  LINE(260);
    {
        locals.err = arrayOPindexes(locals.a, bigintOPmul_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        ret_1->num = elist[0].num;
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(295);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    locals.err = arrayOPtop(locals.a, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_2.num = 134217728;
    T_1_3.num = (T_1_1.num >= T_1_2.num)? true : false;
    if (T_1_3.num == true) {

  LINE(296);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.a.array->ext_size;
        locals.err = intOPadd(T_2_1, CLU_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = bigintOPmul_sub_in(locals.c, locals.b, T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        }
        }
        }/* end if */

  LINE(298);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    locals.err = arrayOPtop(locals.b, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_2.num = 134217728;
    T_1_3.num = (T_1_1.num >= T_1_2.num)? true : false;
    if (T_1_3.num == true) {

  LINE(299);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.b.array->ext_size;
        locals.err = intOPadd(T_2_1, CLU_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = bigintOPmul_sub_in(locals.c, locals.a, T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        }
        }
        }/* end if */

  LINE(301);
    {
    locals.err = bigintOPclear_leads(locals.c);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(302);
    {
    {
    ret_1->num = locals.c.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE mul ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist17 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPmul_actual;
static Vlist1 vals_bigintOPmul = {0, 1, { {0, 2, "", &array_of_int_ops}}
};
static siglist0 sigs_bigintOPmul = {0, 0};
static Vlist17 locals_bigintOPmul = {0, 17,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "c", &array_of_int_ops},  {0, 2, "ia", &int_ops},  {0, 2, "digalo", &int_ops},  {0, 2, "digahi", &int_ops},  {0, 2, "ib", &int_ops},  {0, 2, "digblo", &int_ops},  {0, 2, "digbhi", &int_ops},  {0, 2, "splitd", &int_ops},  {0, 2, "addlo", &int_ops},  {0, 2, "addhi", &int_ops},  {0, 2, "store_at", &int_ops},  {0, 2, "newd", &int_ops},  {0, 2, "add_in", &int_ops},  {0, 2, "a", &array_of_int_ops},  {0, 2, "b", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPmul = {0, 0};
Slist0 tformals_bigintOPmul = {0, 0};
Slist0 opformals_bigintOPmul = {0, 0};
dbg_info_bigintOPmul_actual dbg_info_bigintOPmul_data = {0, 12, 
    "bigintOPmul", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPmul, 2, 
    &vals_bigintOPmul, &sigs_bigintOPmul, &locals_bigintOPmul, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPmul = (struct dbg_info*)&dbg_info_bigintOPmul_data;

/**** BEGIN ITERATOR BODIES for mul ****/

errcode bigintOPmul_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF c;
    CLUREF ia;
    CLUREF digalo;
    CLUREF digahi;
    CLUREF ib;
    CLUREF digblo;
    CLUREF digbhi;
    CLUREF splitd;
    CLUREF addlo;
    CLUREF addhi;
    CLUREF store_at;
    CLUREF newd;
    CLUREF add_in;
    CLUREF a;
    CLUREF b;
    } *locals;
{
    locals->ia.num = iv_1.num;
    enter_iter_body_proc(261);

  FB_LINE(261);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        locals->err = arrayOPfetch(locals->a, locals->ia, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        T_1_2.num = 16384;
        locals->err = intOPmod(T_1_1, T_1_2, &T_1_3);
        if (locals->err != ERR_ok) goto ex_0;
        locals->digalo.num = T_1_3.num;
        }
        }

  FB_LINE(262);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        locals->err = arrayOPfetch(locals->a, locals->ia, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        T_1_2.num = 16384;
        locals->err = intOPdiv(T_1_1, T_1_2, &T_1_3);
        if (locals->err != ERR_ok) goto ex_0;
        locals->digahi.num = T_1_3.num;
        }
        }

  FB_LINE(263);
    {
        locals->err = arrayOPindexes(locals->b, bigintOPmul_IB_2, locals, iecode);
        if (locals->err != ERR_ok) {
        if (locals->err == ERR_iterbodyreturn) {signal(ERR_iterbodyreturn);}
        if (locals->err == ERR_iterbodysignal) {signal(ERR_iterbodysignal);}
        if (locals->err == ERR_break) locals->err = ERR_ok;
        if (locals->err == ERR_iterbodyexit) 
        locals->err = *iecode;
        if (locals->err != ERR_ok) 
        goto ex_0;
        }
        }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end bigintOPmul_IB_1 */
errcode bigintOPmul_IB_2(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF c;
    CLUREF ia;
    CLUREF digalo;
    CLUREF digahi;
    CLUREF ib;
    CLUREF digblo;
    CLUREF digbhi;
    CLUREF splitd;
    CLUREF addlo;
    CLUREF addhi;
    CLUREF store_at;
    CLUREF newd;
    CLUREF add_in;
    CLUREF a;
    CLUREF b;
    } *locals;
{
    locals->ib.num = iv_1.num;
    enter_iter_body_proc(264);

  FB_LINE(264);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        locals->err = arrayOPfetch(locals->b, locals->ib, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        T_1_2.num = 16384;
        locals->err = intOPmod(T_1_1, T_1_2, &T_1_3);
        if (locals->err != ERR_ok) goto ex_0;
        locals->digblo.num = T_1_3.num;
        }
        }

  FB_LINE(265);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        locals->err = arrayOPfetch(locals->b, locals->ib, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        T_1_2.num = 16384;
        locals->err = intOPdiv(T_1_1, T_1_2, &T_1_3);
        if (locals->err != ERR_ok) goto ex_0;
        locals->digbhi.num = T_1_3.num;
        }
        }

  FB_LINE(266);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        locals->err = intOPmul(locals->digalo, locals->digbhi, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = intOPmul(locals->digahi, locals->digblo, &T_1_2);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = intOPadd(T_1_1, T_1_2, &T_1_3);
        if (locals->err != ERR_ok) goto ex_0;
        locals->splitd.num = T_1_3.num;
        }
        }

  FB_LINE(267);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        CLUREF T_1_5;
        CLUREF T_1_6;
        locals->err = intOPmul(locals->digalo, locals->digblo, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        T_1_2.num = 16384;
        locals->err = intOPmod(locals->splitd, T_1_2, &T_1_3);
        if (locals->err != ERR_ok) goto ex_0;
        T_1_4.num = 16384;
        locals->err = intOPmul(T_1_3, T_1_4, &T_1_5);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = intOPadd(T_1_1, T_1_5, &T_1_6);
        if (locals->err != ERR_ok) goto ex_0;
        locals->addlo.num = T_1_6.num;
        }
        }

  FB_LINE(268);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        locals->err = intOPmul(locals->digahi, locals->digbhi, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        T_1_2.num = 16384;
        locals->err = intOPdiv(locals->splitd, T_1_2, &T_1_3);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = intOPadd(T_1_1, T_1_3, &T_1_4);
        if (locals->err != ERR_ok) goto ex_0;
        locals->addhi.num = T_1_4.num;
        }
        }

  FB_LINE(269);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = 268435456;
    T_1_2.num = (locals->addlo.num >= T_1_1.num)? true : false;
    if (T_1_2.num == true) {

  FB_LINE(270);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 268435456;
        locals->err = intOPsub(locals->addlo, T_2_1, &T_2_2);
        if (locals->err != ERR_ok) goto ex_0;
        locals->addlo.num = T_2_2.num;
        }

  FB_LINE(271);
        {
        CLUREF T_2_1;
        locals->err = intOPadd(locals->addhi, CLU_1, &T_2_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->addhi.num = T_2_1.num;
        }
        }
        }/* end if */

  FB_LINE(273);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        locals->err = intOPadd(locals->ia, locals->ib, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = intOPsub(T_1_1, CLU_1, &T_1_2);
        if (locals->err != ERR_ok) goto ex_0;
        locals->store_at.num = T_1_2.num;
        }
        }

  FB_LINE(274);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        locals->err = arrayOPfetch(locals->c, locals->store_at, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = intOPadd(T_1_1, locals->addlo, &T_1_2);
        if (locals->err != ERR_ok) goto ex_0;
        locals->newd.num = T_1_2.num;
        }
        }

  FB_LINE(275);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = 268435456;
    T_1_2.num = (locals->newd.num >= T_1_1.num)? true : false;
    if (T_1_2.num == true) {

  FB_LINE(276);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 268435456;
        locals->err = intOPsub(locals->newd, T_2_1, &T_2_2);
        if (locals->err != ERR_ok) goto ex_0;
        locals->newd.num = T_2_2.num;
        }

  FB_LINE(277);
        {
        CLUREF T_2_1;
        locals->err = intOPadd(locals->addhi, CLU_1, &T_2_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->addhi.num = T_2_1.num;
        }
        }
        }/* end if */

  FB_LINE(279);
    {
    locals->err = arrayOPstore(locals->c, locals->store_at, locals->newd);
    if (locals->err != ERR_ok) goto ex_0;
    }

  FB_LINE(280);
    {
    CLUREF T_1_1;
    locals->err = intOPadd(locals->store_at, CLU_1, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->store_at.num = T_1_1.num;
    }

  FB_LINE(281);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    locals->err = arrayOPfetch(locals->c, locals->store_at, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->err = intOPadd(T_1_1, locals->addhi, &T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    locals->newd.num = T_1_2.num;
    }

  FB_LINE(282);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = 268435456;
    T_1_2.num = (locals->newd.num >= T_1_1.num)? true : false;
    if (T_1_2.num == true) {

  FB_LINE(283);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 268435456;
        locals->err = intOPsub(locals->newd, T_2_1, &T_2_2);
        if (locals->err != ERR_ok) goto ex_0;
        locals->newd.num = T_2_2.num;
        }

  FB_LINE(284);
        {
            {CLUREF T_2_1;
            locals->err = intOPadd(locals->store_at, CLU_1, &T_2_1);
            if (locals->err != ERR_ok) goto ex_0;
            locals->add_in.num = T_2_1.num;
            }
            }

  FB_LINE(285);
        for (;;) {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            locals->err = arrayOPfetch(locals->c, locals->add_in, &T_2_1);
            if (locals->err != ERR_ok) goto ex_0;
            T_2_2.num = 268435455;
            T_2_3.num = (T_2_1.num == T_2_2.num)? true : false;
            if (T_2_3.num != true) { break; }

  FB_LINE(286);
            {
            locals->err = arrayOPstore(locals->c, locals->add_in, CLU_0);
            if (locals->err != ERR_ok) goto ex_0;
            }

  FB_LINE(287);
            {
            CLUREF T_3_1;
            locals->err = intOPadd(locals->add_in, CLU_1, &T_3_1);
            if (locals->err != ERR_ok) goto ex_0;
            locals->add_in.num = T_3_1.num;
            }
            }
            end_while_1:;

  FB_LINE(289);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        locals->err = arrayOPfetch(locals->c, locals->add_in, &T_2_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = intOPadd(T_2_1, CLU_1, &T_2_2);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = arrayOPstore(locals->c, locals->add_in, T_2_2);
        if (locals->err != ERR_ok) goto ex_0;
        }
        }
        }/* end if */

  FB_LINE(291);
    {
    locals->err = arrayOPstore(locals->c, locals->store_at, locals->newd);
    if (locals->err != ERR_ok) goto ex_0;
    }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end bigintOPmul_IB_2 */

/**** END ITERATOR BODIES for mul ****/

extern struct dbg_info* dbg_info_bigintOPmul_sub_in;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPmul_sub_in_TRACE
int bigintOPmul_sub_in_TRACE;
extern errcode bigintOPmul_sub_in_IB_1();
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPmul_sub_in_own_init = 0;

/**** BEGIN PROCEDURE mul_sub_in ****/

errcode bigintOPmul_sub_in(c, a, p)
CLUREF c;
CLUREF a;
CLUREF p;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF carry;
        CLUREF aa;
        CLUREF newc;
        CLUREF c;
        CLUREF a;
        CLUREF p;
        } locals;
    locals.carry.num = UNINIT;
    locals.aa.num = UNINIT;
    locals.newc.num = UNINIT;
    locals.c.num = UNINIT;
    locals.a.num = UNINIT;
    locals.p.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPmul_sub_in;
    locals.c = c;
    locals.a = a;
    locals.p = p;
        if (bigintOPmul_sub_in_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPmul_sub_in_own_init = 1;
    }
    enter_proc(306);

  LINE(307);
    {
        {locals.carry.num = 1;
        }
        }

  LINE(308);
    {
        locals.err = arrayOPelements(locals.a, bigintOPmul_sub_in_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_0;
        }
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE mul_sub_in ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist8 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPmul_sub_in_actual;
static Vlist0 vals_bigintOPmul_sub_in = {0, 0};
static siglist0 sigs_bigintOPmul_sub_in = {0, 0};
static Vlist8 locals_bigintOPmul_sub_in = {0, 8,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "carry", &int_ops},  {0, 2, "aa", &int_ops},  {0, 2, "newc", &int_ops},  {0, 2, "c", &array_of_int_ops},  {0, 2, "a", &array_of_int_ops},  {0, 2, "p", &int_ops}}
};
static Vlist0 popowns_bigintOPmul_sub_in = {0, 0};
Slist0 tformals_bigintOPmul_sub_in = {0, 0};
Slist0 opformals_bigintOPmul_sub_in = {0, 0};
dbg_info_bigintOPmul_sub_in_actual dbg_info_bigintOPmul_sub_in_data = {0, 12, 
    "bigintOPmul_sub_in", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPmul_sub_in, 3, 
    &vals_bigintOPmul_sub_in, &sigs_bigintOPmul_sub_in, &locals_bigintOPmul_sub_in, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPmul_sub_in = (struct dbg_info*)&dbg_info_bigintOPmul_sub_in_data;

/**** BEGIN ITERATOR BODIES for mul_sub_in ****/

errcode bigintOPmul_sub_in_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF carry;
    CLUREF aa;
    CLUREF newc;
    CLUREF c;
    CLUREF a;
    CLUREF p;
    } *locals;
{
    locals->aa.num = iv_1.num;
    enter_iter_body_proc(309);

  FB_LINE(309);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        CLUREF T_1_5;
        locals->err = arrayOPfetch(locals->c, locals->p, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        T_1_2.num = 268435455;
        locals->err = intOPsub(T_1_2, locals->aa, &T_1_3);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = intOPadd(T_1_1, T_1_3, &T_1_4);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = intOPadd(T_1_4, locals->carry, &T_1_5);
        if (locals->err != ERR_ok) goto ex_0;
        locals->newc.num = T_1_5.num;
        }
        }

  FB_LINE(310);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = 268435456;
    T_1_2.num = (locals->newc.num >= T_1_1.num)? true : false;
    if (T_1_2.num == true) {

  FB_LINE(311);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 268435456;
        locals->err = intOPsub(locals->newc, T_2_1, &T_2_2);
        if (locals->err != ERR_ok) goto ex_0;
        locals->newc.num = T_2_2.num;
        }

  FB_LINE(312);
        {
        locals->carry.num = 1;
        }
        }
    else {

  FB_LINE(314);
        {
        locals->carry.num = 0;
        }
        }}/* end if */

  FB_LINE(316);
    {
    locals->err = arrayOPstore(locals->c, locals->p, locals->newc);
    if (locals->err != ERR_ok) goto ex_0;
    }

  FB_LINE(317);
    {
    CLUREF T_1_1;
    locals->err = intOPadd(locals->p, CLU_1, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->p.num = T_1_1.num;
    }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end bigintOPmul_sub_in_IB_1 */

/**** END ITERATOR BODIES for mul_sub_in ****/

extern struct dbg_info* dbg_info_bigintOPclear_leads;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPclear_leads_TRACE
int bigintOPclear_leads_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPclear_leads_own_init = 0;

/**** BEGIN PROCEDURE clear_leads ****/

errcode bigintOPclear_leads(r)
CLUREF r;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF fd;
        CLUREF rsz;
        CLUREF r;
        } locals;
    locals.fd.num = UNINIT;
    locals.rsz.num = UNINIT;
    locals.r.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPclear_leads;
    locals.r = r;
        if (bigintOPclear_leads_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPclear_leads_own_init = 1;
    }
    enter_proc(323);

  LINE(324);
    {
        {CLUREF T_1_1;
        locals.err = arrayOPtop(locals.r, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.fd.num = T_1_1.num;
        }
        }

  LINE(326);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_2.num = (locals.fd.num == 0)? true : false;
    T_1_1.num = T_1_2.num;
    if (!T_1_2.num) {
        T_1_3.num = 268435455;
        T_1_4.num = (locals.fd.num == T_1_3.num)? true : false;
        T_1_1.num = T_1_4.num;
    }
    if (T_1_1.num == true) {

  LINE(327);
        {
            {CLUREF T_2_1;
            CLUREF T_2_2;
            T_2_1.num = locals.r.array->ext_size;
            locals.err = intOPsub(T_2_1, CLU_1, &T_2_2);
            if (locals.err != ERR_ok) goto ex_0;
            locals.rsz.num = T_2_2.num;
            }
            }

  LINE(328);
        {

  LINE(329);
            for (;;) {
                CLUREF T_4_1;
                CLUREF T_4_2;
                locals.err = arrayOPfetch(locals.r, locals.rsz, &T_4_1);
                if (locals.err != ERR_ok) goto ex_1;
                T_4_2.num = (T_4_1.num == locals.fd.num)? true : false;
                if (T_4_2.num != true) { break; }
                {
                CLUREF T_5_1;
                locals.err = intOPsub(locals.rsz, CLU_1, &T_5_1);
                if (locals.err != ERR_ok) goto ex_1;
                locals.rsz.num = T_5_1.num;
                }
                }
                end_while_1:;

  LINE(330);
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            CLUREF T_4_3;
            CLUREF T_4_4;
            CLUREF T_4_5;
            CLUREF T_4_6;
            CLUREF T_4_7;
            CLUREF T_4_8;
            CLUREF T_4_9;
            CLUREF T_4_10;
            CLUREF T_4_11;
            CLUREF T_4_12;
            T_4_3.num = (locals.fd.num == 0)? true : false;
            T_4_2.num = T_4_3.num;
            if (T_4_3.num) {
                locals.err = arrayOPfetch(locals.r, locals.rsz, &T_4_4);
                if (locals.err != ERR_ok) goto ex_1;
                T_4_5.num = 134217728;
                T_4_6.num = (T_4_4.num >= T_4_5.num)? true : false;
                T_4_2.num = T_4_6.num;
            }
            T_4_1.num = T_4_2.num;
            if (!T_4_2.num) {
                T_4_8.num = 268435455;
                T_4_9.num = (locals.fd.num == T_4_8.num)? true : false;
                T_4_7.num = T_4_9.num;
                if (T_4_9.num) {
                    locals.err = arrayOPfetch(locals.r, locals.rsz, &T_4_10);
                    if (locals.err != ERR_ok) goto ex_1;
                    T_4_11.num = 134217728;
                    T_4_12.num = (T_4_10.num < T_4_11.num)? true : false;
                    T_4_7.num = T_4_12.num;
                }
                T_4_1.num = T_4_7.num;
            }
            if (T_4_1.num == true) {

  LINE(331);
                {
                CLUREF T_5_1;
                locals.err = intOPadd(locals.rsz, CLU_1, &T_5_1);
                if (locals.err != ERR_ok) goto ex_1;
                locals.rsz.num = T_5_1.num;
                }
                }
                }/* end if */
            }
            goto end_1;
            ex_1:
                if ((locals.err == ERR_bounds)) {

  LINE(333);
                    {
                    locals.rsz.num = 1;
                    }
                }
                else {
                    goto ex_0;
                }
            end_1:;

  LINE(334);
        {
        locals.err = arrayOPtrim(locals.r, CLU_1, locals.rsz);
        if (locals.err != ERR_ok) goto ex_0;
        }
        }
        }/* end if */
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE clear_leads ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist5 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPclear_leads_actual;
static Vlist0 vals_bigintOPclear_leads = {0, 0};
static siglist0 sigs_bigintOPclear_leads = {0, 0};
static Vlist5 locals_bigintOPclear_leads = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "fd", &int_ops},  {0, 2, "rsz", &int_ops},  {0, 2, "r", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPclear_leads = {0, 0};
Slist0 tformals_bigintOPclear_leads = {0, 0};
Slist0 opformals_bigintOPclear_leads = {0, 0};
dbg_info_bigintOPclear_leads_actual dbg_info_bigintOPclear_leads_data = {0, 12, 
    "bigintOPclear_leads", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPclear_leads, 1, 
    &vals_bigintOPclear_leads, &sigs_bigintOPclear_leads, &locals_bigintOPclear_leads, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPclear_leads = (struct dbg_info*)&dbg_info_bigintOPclear_leads_data;
extern struct dbg_info* dbg_info_bigintOPpower;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPpower_TRACE
int bigintOPpower_TRACE;
extern errcode bigintOPpower_IB_1();
extern errcode bigintOPpower_IB_2();
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPpower_own_init = 0;

/**** BEGIN PROCEDURE power ****/

errcode bigintOPpower(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF pexp;
        CLUREF sexp;
        CLUREF w;
        CLUREF x;
        CLUREF d;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.pexp.num = UNINIT;
    locals.sexp.num = UNINIT;
    locals.w.num = UNINIT;
    locals.x.num = UNINIT;
    locals.d.num = UNINIT;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPpower;
    locals.a = a;
    locals.b = b;
        if (bigintOPpower_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPpower_own_init = 1;
    }
    enter_proc(339);

  LINE(340);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    locals.err = arrayOPtop(locals.b, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_2.num = 134217728;
    T_1_3.num = (T_1_1.num >= T_1_2.num)? true : false;
    if (T_1_3.num == true) {
        {
        {signal (ERR_negative_exponent);}}
        }
        }/* end if */

  LINE(346);
    {
        {locals.pexp.num = locals.a.num;
        }
        }

  LINE(347);
    {
        {CLUREF T_1_1;
        locals.err = arrayOPnew( &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = arrayOPaddh(T_1_1, CLU_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.sexp.num = T_1_1.num;
        }
        }

  LINE(348);
    {
        locals.err = arrayOPindexes(locals.b, bigintOPpower_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        ret_1->num = elist[0].num;
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(360);
    {
    {
    ret_1->num = locals.sexp.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE power ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist9 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPpower_actual;
static Vlist1 vals_bigintOPpower = {0, 1, { {0, 2, "", &bigint_ops}}
};
static sig_desc0 sig_bigintOPpower_1 = {0, 3, "negative_exponent", {0, 0
}};
static siglist1 sigs_bigintOPpower = {0, 1, (sig_desc*)&sig_bigintOPpower_1};
static Vlist9 locals_bigintOPpower = {0, 9,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "pexp", &bigint_ops},  {0, 2, "sexp", &bigint_ops},  {0, 2, "w", &int_ops},  {0, 2, "x", &int_ops},  {0, 2, "d", &int_ops},  {0, 2, "a", &bigint_ops},  {0, 2, "b", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPpower = {0, 0};
Slist0 tformals_bigintOPpower = {0, 0};
Slist0 opformals_bigintOPpower = {0, 0};
dbg_info_bigintOPpower_actual dbg_info_bigintOPpower_data = {0, 12, 
    "bigintOPpower", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPpower, 2, 
    &vals_bigintOPpower, &sigs_bigintOPpower, &locals_bigintOPpower, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPpower = (struct dbg_info*)&dbg_info_bigintOPpower_data;

/**** BEGIN ITERATOR BODIES for power ****/

errcode bigintOPpower_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF pexp;
    CLUREF sexp;
    CLUREF w;
    CLUREF x;
    CLUREF d;
    CLUREF a;
    CLUREF b;
    } *locals;
{
    locals->w.num = iv_1.num;
    enter_iter_body_proc(349);

  FB_LINE(349);
    {
        {CLUREF T_1_1;
        locals->err = arrayOPfetch(locals->b, locals->w, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->x.num = T_1_1.num;
        }
        }

  FB_LINE(350);
    {
        locals->err = intOPfrom_to(CLU_0, CLU_31, bigintOPpower_IB_2, locals, iecode);
        if (locals->err != ERR_ok) {
        if (locals->err == ERR_iterbodyreturn) {signal(ERR_iterbodyreturn);}
        if (locals->err == ERR_iterbodysignal) {signal(ERR_iterbodysignal);}
        if (locals->err == ERR_break) locals->err = ERR_ok;
        if (locals->err == ERR_iterbodyexit) 
        locals->err = *iecode;
        if (locals->err != ERR_ok) 
        goto ex_0;
        }
        }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end bigintOPpower_IB_1 */
errcode bigintOPpower_IB_2(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF pexp;
    CLUREF sexp;
    CLUREF w;
    CLUREF x;
    CLUREF d;
    CLUREF a;
    CLUREF b;
    } *locals;
{
    locals->d.num = iv_1.num;
    enter_iter_body_proc(351);

  FB_LINE(351);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    locals->err = intOPmod(locals->x, CLU_2, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    T_1_2.num = (T_1_1.num == 1)? true : false;
    if (T_1_2.num == true) {

  FB_LINE(352);
        {
        CLUREF T_2_1;
        locals->err = bigintOPmul(locals->sexp, locals->pexp, &T_2_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->sexp.num = T_2_1.num;
        }
        }
        }/* end if */

  FB_LINE(354);
    {
    CLUREF T_1_1;
    locals->err = intOPdiv(locals->x, CLU_2, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->x.num = T_1_1.num;
    }

  FB_LINE(356);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_2.num = (locals->x.num == 0)? true : false;
    T_1_1.num = T_1_2.num;
    if (T_1_2.num) {
        T_1_3.num = locals->b.array->ext_size;
        T_1_4.num = (locals->w.num == T_1_3.num)? true : false;
        T_1_1.num = T_1_4.num;
    }
    if (T_1_1.num == true) {
        {signal(ERR_break);}
        }
        }/* end if */

  FB_LINE(357);
    {
    CLUREF T_1_1;
    locals->err = bigintOPmul(locals->pexp, locals->pexp, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->pexp.num = T_1_1.num;
    }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end bigintOPpower_IB_2 */

/**** END ITERATOR BODIES for power ****/

extern struct dbg_info* dbg_info_bigintOPdiv;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPdiv_TRACE
int bigintOPdiv_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPdiv_own_init = 0;

/**** BEGIN PROCEDURE div ****/

errcode bigintOPdiv(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF q;
        CLUREF r;
        CLUREF nega;
        CLUREF negb;
        CLUREF mod0;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.q.num = UNINIT;
    locals.r.num = UNINIT;
    locals.nega.num = UNINIT;
    locals.negb.num = UNINIT;
    locals.mod0.num = UNINIT;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPdiv;
    locals.a = a;
    locals.b = b;
        if (bigintOPdiv_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPdiv_own_init = 1;
    }
    enter_proc(364);

  LINE(365);
    {
        {CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        CLUREF T_2_5;
        locals.err = bigintOPdivmodhack(locals.a, locals.b, &T_2_1, &T_2_2, &T_2_3, &T_2_4, &T_2_5);
        if (locals.err != ERR_ok) goto ex_1;
        locals.q.num = T_2_1.num;
        locals.r.num = T_2_2.num;
        locals.nega.num = T_2_3.num;
        locals.negb.num = T_2_4.num;
        locals.mod0.num = T_2_5.num;
        }
        }
    goto end_1;
    ex_1:
        if (locals.err == ERR_zero_divide) {signal(ERR_zero_divide);}
        else {
            goto ex_0;}
    end_1:;

  LINE(366);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_2.num = locals.mod0.num ^ 1;
    T_1_1.num = T_1_2.num;
    if (T_1_2.num) {
        T_1_1.num = locals.nega.num;
    }
    if (T_1_1.num == true) {

  LINE(367);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        locals.err = arrayOPnew( &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = arrayOPaddh(T_2_1, CLU_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = bigintOPadd(locals.q, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.q.num = T_2_2.num;
        }
        }
        }/* end if */

  LINE(369);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = (locals.nega.tf == locals.negb.tf)? true : false;
    T_1_2.num = T_1_1.num ^ 1;
    if (T_1_2.num == true) {

  LINE(370);
        {
        CLUREF T_2_1;
        locals.err = bigintOPminus(locals.q, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.q.num = T_2_1.num;
        }
        }
        }/* end if */

  LINE(372);
    {
    {
    ret_1->num = locals.q.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE div ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist9 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPdiv_actual;
static Vlist1 vals_bigintOPdiv = {0, 1, { {0, 2, "", &bigint_ops}}
};
static sig_desc0 sig_bigintOPdiv_1 = {0, 3, "zero_divide", {0, 0
}};
static siglist1 sigs_bigintOPdiv = {0, 1, (sig_desc*)&sig_bigintOPdiv_1};
static Vlist9 locals_bigintOPdiv = {0, 9,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "q", &bigint_ops},  {0, 2, "r", &bigint_ops},  {0, 2, "nega", &bool_ops},  {0, 2, "negb", &bool_ops},  {0, 2, "mod0", &bool_ops},  {0, 2, "a", &bigint_ops},  {0, 2, "b", &bigint_ops}}
};
static Vlist0 popowns_bigintOPdiv = {0, 0};
Slist0 tformals_bigintOPdiv = {0, 0};
Slist0 opformals_bigintOPdiv = {0, 0};
dbg_info_bigintOPdiv_actual dbg_info_bigintOPdiv_data = {0, 12, 
    "bigintOPdiv", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPdiv, 2, 
    &vals_bigintOPdiv, &sigs_bigintOPdiv, &locals_bigintOPdiv, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPdiv = (struct dbg_info*)&dbg_info_bigintOPdiv_data;
extern struct dbg_info* dbg_info_bigintOPmod;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPmod_TRACE
int bigintOPmod_TRACE;
static int bigintOPmod_own_init = 0;

/**** BEGIN PROCEDURE mod ****/

errcode bigintOPmod(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF q;
        CLUREF r;
        CLUREF nega;
        CLUREF negb;
        CLUREF mod0;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.q.num = UNINIT;
    locals.r.num = UNINIT;
    locals.nega.num = UNINIT;
    locals.negb.num = UNINIT;
    locals.mod0.num = UNINIT;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPmod;
    locals.a = a;
    locals.b = b;
        if (bigintOPmod_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPmod_own_init = 1;
    }
    enter_proc(375);

  LINE(376);
    {
        {CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        CLUREF T_2_5;
        locals.err = bigintOPdivmodhack(locals.a, locals.b, &T_2_1, &T_2_2, &T_2_3, &T_2_4, &T_2_5);
        if (locals.err != ERR_ok) goto ex_1;
        locals.q.num = T_2_1.num;
        locals.r.num = T_2_2.num;
        locals.nega.num = T_2_3.num;
        locals.negb.num = T_2_4.num;
        locals.mod0.num = T_2_5.num;
        }
        }
    goto end_1;
    ex_1:
        if (locals.err == ERR_zero_divide) {signal(ERR_zero_divide);}
        else {
            goto ex_0;}
    end_1:;

  LINE(377);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.mod0.num;
    if (!locals.mod0.num) {
        T_1_2.num = locals.nega.num ^ 1;
        T_1_1.num = T_1_2.num;
    }
    if (T_1_1.num == true) {

  LINE(378);
        {
        {
        ret_1->num = locals.r.num;
        }
        {signal (ERR_ok);}}
        }
    else {
    CLUREF T_1_3;
    T_1_3.num = locals.negb.num ^ 1;
    if (T_1_3.num == true) {

  LINE(380);
        {
        {
        CLUREF T_2_1;
        locals.err = bigintOPsub(locals.b, locals.r, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        ret_1->num = T_2_1.num;
        }
        {signal (ERR_ok);}}
        }
    else {

  LINE(382);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        locals.err = bigintOPminus(locals.b, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = bigintOPsub(T_2_1, locals.r, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        ret_1->num = T_2_2.num;
        }
        {signal (ERR_ok);}}
        }}}/* end if */
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE mod ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist9 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPmod_actual;
static Vlist1 vals_bigintOPmod = {0, 1, { {0, 2, "", &bigint_ops}}
};
static sig_desc0 sig_bigintOPmod_1 = {0, 3, "zero_divide", {0, 0
}};
static siglist1 sigs_bigintOPmod = {0, 1, (sig_desc*)&sig_bigintOPmod_1};
static Vlist9 locals_bigintOPmod = {0, 9,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "q", &bigint_ops},  {0, 2, "r", &bigint_ops},  {0, 2, "nega", &bool_ops},  {0, 2, "negb", &bool_ops},  {0, 2, "mod0", &bool_ops},  {0, 2, "a", &bigint_ops},  {0, 2, "b", &bigint_ops}}
};
static Vlist0 popowns_bigintOPmod = {0, 0};
Slist0 tformals_bigintOPmod = {0, 0};
Slist0 opformals_bigintOPmod = {0, 0};
dbg_info_bigintOPmod_actual dbg_info_bigintOPmod_data = {0, 12, 
    "bigintOPmod", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPmod, 2, 
    &vals_bigintOPmod, &sigs_bigintOPmod, &locals_bigintOPmod, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPmod = (struct dbg_info*)&dbg_info_bigintOPmod_data;
extern struct dbg_info* dbg_info_bigintOPdivmodhack;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPdivmodhack_TRACE
int bigintOPdivmodhack_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPdivmodhack_own_init = 0;

/**** BEGIN PROCEDURE divmodhack ****/

errcode bigintOPdivmodhack(a, b, ret_1, ret_2, ret_3, ret_4, ret_5)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
CLUREF *ret_2;
CLUREF *ret_3;
CLUREF *ret_4;
CLUREF *ret_5;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF q;
        CLUREF r;
        CLUREF nega;
        CLUREF negb;
        CLUREF mod0;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.q.num = UNINIT;
    locals.r.num = UNINIT;
    locals.nega.num = UNINIT;
    locals.negb.num = UNINIT;
    locals.mod0.num = UNINIT;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPdivmodhack;
    locals.a = a;
    locals.b = b;
        if (bigintOPdivmodhack_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPdivmodhack_own_init = 1;
    }
    enter_proc(386);

  LINE(388);
    locals.q.num = UNINIT;
    locals.r.num = UNINIT;
    locals.nega.num = UNINIT;
    locals.negb.num = UNINIT;
    locals.mod0.num = UNINIT;

  LINE(389);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    locals.err = arrayOPtop(locals.a, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_2.num = 134217728;
    T_1_3.num = (T_1_1.num >= T_1_2.num)? true : false;
    if (T_1_3.num == true) {

  LINE(390);
        {
        CLUREF T_2_1;
        locals.err = bigintOPminus(locals.a, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.a.num = T_2_1.num;
        }

  LINE(391);
        {
        locals.nega.tf = true;
        }
        }
    else {

  LINE(393);
        {
        locals.nega.tf = false;
        }
        }}/* end if */

  LINE(395);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    locals.err = arrayOPtop(locals.b, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_2.num = 134217728;
    T_1_3.num = (T_1_1.num >= T_1_2.num)? true : false;
    if (T_1_3.num == true) {

  LINE(396);
        {
        CLUREF T_2_1;
        locals.err = bigintOPminus(locals.b, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.b.num = T_2_1.num;
        }

  LINE(397);
        {
        locals.negb.tf = true;
        }
        }
    else {

  LINE(399);
        {
        locals.negb.tf = false;
        }
        }}/* end if */

  LINE(401);
    {
    CLUREF T_2_1;
    CLUREF T_2_2;
    locals.err = bigintOPdivmod(locals.a, locals.b, &T_2_1, &T_2_2);
    if (locals.err != ERR_ok) goto ex_1;
    locals.q.num = T_2_1.num;
    locals.r.num = T_2_2.num;
    }
    goto end_1;
    ex_1:
        if (locals.err == ERR_zero_divide) {signal(ERR_zero_divide);}
        else {
            goto ex_0;}
    end_1:;

  LINE(402);
    {
    CLUREF T_1_1;
    locals.err = bigintOPold_base(locals.q, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    locals.q.num = T_1_1.num;
    }

  LINE(403);
    {
    CLUREF T_1_1;
    locals.err = bigintOPold_base(locals.r, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    locals.r.num = T_1_1.num;
    }

  LINE(404);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    CLUREF T_1_5;
    T_1_2.num = locals.r.array->ext_size;
    T_1_3.num = (T_1_2.num == 1)? true : false;
    T_1_1.num = T_1_3.num;
    if (T_1_3.num) {
        locals.err = arrayOPfetch(locals.r, CLU_1, &T_1_4);
        if (locals.err != ERR_ok) goto ex_0;
        T_1_5.num = (T_1_4.num == 0)? true : false;
        T_1_1.num = T_1_5.num;
    }
    if (T_1_1.num == true) {

  LINE(405);
        {
        locals.mod0.tf = true;
        }
        }
    else {

  LINE(407);
        {
        locals.mod0.tf = false;
        }
        }}/* end if */

  LINE(409);
    {
    {
    ret_1->num = locals.q.num;
    }
    {
    ret_2->num = locals.r.num;
    }
    {
    ret_3->num = locals.nega.num;
    }
    {
    ret_4->num = locals.negb.num;
    }
    {
    ret_5->num = locals.mod0.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE divmodhack ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist5 *vals;
    siglist1 *sigs;
    Vlist9 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPdivmodhack_actual;
static Vlist5 vals_bigintOPdivmodhack = {0, 5, { {0, 2, "", &array_of_int_ops},  {0, 2, "", &array_of_int_ops},  {0, 2, "", &bool_ops},  {0, 2, "", &bool_ops},  {0, 2, "", &bool_ops}}
};
static sig_desc0 sig_bigintOPdivmodhack_1 = {0, 3, "zero_divide", {0, 0
}};
static siglist1 sigs_bigintOPdivmodhack = {0, 1, (sig_desc*)&sig_bigintOPdivmodhack_1};
static Vlist9 locals_bigintOPdivmodhack = {0, 9,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "q", &array_of_int_ops},  {0, 2, "r", &array_of_int_ops},  {0, 2, "nega", &bool_ops},  {0, 2, "negb", &bool_ops},  {0, 2, "mod0", &bool_ops},  {0, 2, "a", &array_of_int_ops},  {0, 2, "b", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPdivmodhack = {0, 0};
Slist0 tformals_bigintOPdivmodhack = {0, 0};
Slist0 opformals_bigintOPdivmodhack = {0, 0};
dbg_info_bigintOPdivmodhack_actual dbg_info_bigintOPdivmodhack_data = {0, 12, 
    "bigintOPdivmodhack", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPdivmodhack, 2, 
    &vals_bigintOPdivmodhack, &sigs_bigintOPdivmodhack, &locals_bigintOPdivmodhack, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPdivmodhack = (struct dbg_info*)&dbg_info_bigintOPdivmodhack_data;
extern struct dbg_info* dbg_info_bigintOPdivmod;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPdivmod_TRACE
int bigintOPdivmod_TRACE;
extern errcode bigintOPdivmod_IB_1();
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPdivmod_own_init = 0;

/**** BEGIN PROCEDURE divmod ****/

errcode bigintOPdivmod(a, b, ret_1, ret_2)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
CLUREF *ret_2;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF newba;
        CLUREF newbb;
        CLUREF forget_it;
        CLUREF remainder;
        CLUREF rsize;
        CLUREF r;
        CLUREF e;
        CLUREF a;
        CLUREF b;
        } locals;
    locals.newba.num = UNINIT;
    locals.newbb.num = UNINIT;
    locals.forget_it.num = UNINIT;
    locals.remainder.num = UNINIT;
    locals.rsize.num = UNINIT;
    locals.r.num = UNINIT;
    locals.e.num = UNINIT;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPdivmod;
    locals.a = a;
    locals.b = b;
        if (bigintOPdivmod_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPdivmod_own_init = 1;
    }
    enter_proc(412);

  LINE(413);
    {
        {CLUREF T_1_1;
        locals.err = bigintOPnew_base(locals.a, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.newba.num = T_1_1.num;
        }
        }

  LINE(414);
    {
        {CLUREF T_1_1;
        locals.err = bigintOPnew_base(locals.b, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.newbb.num = T_1_1.num;
        }
        }

  LINE(415);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.newbb.array->ext_size;
    T_1_2.num = (T_1_1.num == 1)? true : false;
    if (T_1_2.num == true) {

  LINE(416);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        locals.err = arrayOPfetch(locals.newbb, CLU_1, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        T_2_2.num = (T_2_1.num == 0)? true : false;
        if (T_2_2.num == true) {
            {
            {signal (ERR_zero_divide);}}
            }
            }/* end if */

  LINE(417);
        {
            {CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            locals.err = arrayOPfetch(locals.newbb, CLU_1, &T_2_1);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = bigintOPone_digit_divide(locals.newba, T_2_1, &T_2_2, &T_2_3);
            if (locals.err != ERR_ok) goto ex_0;
            locals.forget_it.num = T_2_2.num;
            locals.remainder.num = T_2_3.num;
            }
            }

  LINE(418);
        {
        {
        ret_1->num = locals.newba.num;
        }
        {
        CLUREF T_2_1;
        locals.err = arrayOPnew( &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = arrayOPaddh(T_2_1, locals.remainder);
        if (locals.err != ERR_ok) goto ex_0;
        ret_2->num = T_2_1.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(420);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        T_1_1.num = locals.newba.array->ext_size;
        T_1_2.num = locals.newbb.array->ext_size;
        locals.err = intOPsub(T_1_1, T_1_2, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPadd(T_1_3, CLU_1, &T_1_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.rsize.num = T_1_4.num;
        }
        }

  LINE(421);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals.rsize.num <= 0)? true : false;
    if (T_1_1.num == true) {

  LINE(422);
        {
        {
        CLUREF T_2_1;
        locals.err = arrayOPnew( &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = arrayOPaddh(T_2_1, CLU_0);
        if (locals.err != ERR_ok) goto ex_0;
        ret_1->num = T_2_1.num;
        }
        {
        ret_2->num = locals.newba.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(424);
    {
    locals.err = arrayOPaddh(locals.newba, CLU_0);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(425);
    {
        {CLUREF T_1_1;
        locals.err = arrayOPfill(CLU_1, locals.rsize, CLU_0, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.r.num = T_1_1.num;
        }
        }

  LINE(426);
    {
        CLUREF T_1_1;
        T_1_1.num = -1;
        locals.err = intOPfrom_to_by(locals.rsize, CLU_1, T_1_1, bigintOPdivmod_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        ret_1->num = elist[0].num;
        ret_2->num = elist[1].num;
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(429);
    {
    {
    ret_1->num = locals.r.num;
    }
    {
    ret_2->num = locals.newba.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE divmod ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist2 *vals;
    siglist1 *sigs;
    Vlist11 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPdivmod_actual;
static Vlist2 vals_bigintOPdivmod = {0, 2, { {0, 2, "", &array_of_int_ops},  {0, 2, "", &array_of_int_ops}}
};
static sig_desc0 sig_bigintOPdivmod_1 = {0, 3, "zero_divide", {0, 0
}};
static siglist1 sigs_bigintOPdivmod = {0, 1, (sig_desc*)&sig_bigintOPdivmod_1};
static Vlist11 locals_bigintOPdivmod = {0, 11,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "newba", &array_of_int_ops},  {0, 2, "newbb", &array_of_int_ops},  {0, 2, "forget_it", &bool_ops},  {0, 2, "remainder", &int_ops},  {0, 2, "rsize", &int_ops},  {0, 2, "r", &array_of_int_ops},  {0, 2, "e", &int_ops},  {0, 2, "a", &array_of_int_ops},  {0, 2, "b", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPdivmod = {0, 0};
Slist0 tformals_bigintOPdivmod = {0, 0};
Slist0 opformals_bigintOPdivmod = {0, 0};
dbg_info_bigintOPdivmod_actual dbg_info_bigintOPdivmod_data = {0, 12, 
    "bigintOPdivmod", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPdivmod, 2, 
    &vals_bigintOPdivmod, &sigs_bigintOPdivmod, &locals_bigintOPdivmod, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPdivmod = (struct dbg_info*)&dbg_info_bigintOPdivmod_data;

/**** BEGIN ITERATOR BODIES for divmod ****/

errcode bigintOPdivmod_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF newba;
    CLUREF newbb;
    CLUREF forget_it;
    CLUREF remainder;
    CLUREF rsize;
    CLUREF r;
    CLUREF e;
    CLUREF a;
    CLUREF b;
    } *locals;
{
    locals->e.num = iv_1.num;
    enter_iter_body_proc(427);

  FB_LINE(427);
    {
    CLUREF T_1_1;
    locals->err = bigintOPdiv_one(locals->newba, locals->newbb, locals->e, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->err = arrayOPstore(locals->r, locals->e, T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end bigintOPdivmod_IB_1 */

/**** END ITERATOR BODIES for divmod ****/

extern struct dbg_info* dbg_info_bigintOPdiv_one;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPdiv_one_TRACE
int bigintOPdiv_one_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPdiv_one_own_init = 0;

/**** BEGIN PROCEDURE div_one ****/

errcode bigintOPdiv_one(iden, isor, e, ret_1)
CLUREF iden;
CLUREF isor;
CLUREF e;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ssz;
        CLUREF d;
        CLUREF divsofar;
        CLUREF quess;
        CLUREF iden;
        CLUREF isor;
        CLUREF e;
        } locals;
    locals.ssz.num = UNINIT;
    locals.d.num = UNINIT;
    locals.divsofar.num = UNINIT;
    locals.quess.num = UNINIT;
    locals.iden.num = UNINIT;
    locals.isor.num = UNINIT;
    locals.e.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPdiv_one;
    locals.iden = iden;
    locals.isor = isor;
    locals.e = e;
        if (bigintOPdiv_one_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPdiv_one_own_init = 1;
    }
    enter_proc(434);

  LINE(435);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.isor.array->ext_size;
        locals.ssz.num = T_1_1.num;
        }
        }

  LINE(436);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = locals.isor.array->ext_size;
        locals.err = intOPadd(locals.e, T_1_1, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPsub(T_1_2, CLU_1, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.d.num = T_1_3.num;
        }
        }

  LINE(440);
    {
        {locals.divsofar.num = 0;
        }
        }

  LINE(441);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        locals.err = bigintOPdiv_lt(locals.iden, locals.isor, locals.e, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        T_1_2.num = T_1_1.num ^ 1;
        if (T_1_2.num != true) { break; }

  LINE(443);
        locals.quess.num = UNINIT;

  LINE(444);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        locals.err = intOPadd(locals.d, CLU_1, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = arrayOPfetch(locals.iden, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        T_2_3.num = (T_2_2.num == 0)? true : false;
        if (T_2_3.num == true) {

  LINE(445);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            CLUREF T_3_3;
            CLUREF T_3_4;
            CLUREF T_3_5;
            CLUREF T_3_6;
            CLUREF T_3_7;
            CLUREF T_3_8;
            CLUREF T_3_9;
            CLUREF T_3_10;
            CLUREF T_3_11;
            CLUREF T_3_12;
            CLUREF T_3_13;
            CLUREF T_3_14;
            locals.err = arrayOPfetch(locals.iden, locals.d, &T_3_1);
            if (locals.err != ERR_ok) goto ex_0;
            T_3_2.num = 16384;
            locals.err = intOPmul(T_3_1, T_3_2, &T_3_3);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = intOPsub(locals.d, CLU_1, &T_3_4);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = arrayOPfetch(locals.iden, T_3_4, &T_3_5);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = intOPadd(T_3_3, T_3_5, &T_3_6);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = arrayOPfetch(locals.isor, locals.ssz, &T_3_7);
            if (locals.err != ERR_ok) goto ex_0;
            T_3_8.num = 16384;
            locals.err = intOPmul(T_3_7, T_3_8, &T_3_9);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = intOPsub(locals.ssz, CLU_1, &T_3_10);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = arrayOPfetch(locals.isor, T_3_10, &T_3_11);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = intOPadd(T_3_9, T_3_11, &T_3_12);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = intOPadd(T_3_12, CLU_1, &T_3_13);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = intOPdiv(T_3_6, T_3_13, &T_3_14);
            if (locals.err != ERR_ok) goto ex_0;
            locals.quess.num = T_3_14.num;
            }
            }
        else {

  LINE(448);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            CLUREF T_3_3;
            CLUREF T_3_4;
            CLUREF T_3_5;
            CLUREF T_3_6;
            CLUREF T_3_7;
            CLUREF T_3_8;
            CLUREF T_3_9;
            locals.err = intOPadd(locals.d, CLU_1, &T_3_1);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = arrayOPfetch(locals.iden, T_3_1, &T_3_2);
            if (locals.err != ERR_ok) goto ex_0;
            T_3_3.num = 16384;
            locals.err = intOPmul(T_3_2, T_3_3, &T_3_4);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = arrayOPfetch(locals.iden, locals.d, &T_3_5);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = intOPadd(T_3_4, T_3_5, &T_3_6);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = arrayOPfetch(locals.isor, locals.ssz, &T_3_7);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = intOPadd(T_3_7, CLU_1, &T_3_8);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = intOPdiv(T_3_6, T_3_8, &T_3_9);
            if (locals.err != ERR_ok) goto ex_0;
            locals.quess.num = T_3_9.num;
            }
            }}/* end if */

  LINE(450);
        {
        CLUREF T_2_1;
        T_2_1.num = (locals.quess.num == 0)? true : false;
        if (T_2_1.num == true) {
            {
            locals.quess.num = 1;
            }
            }
            }/* end if */

  LINE(451);
        {
        locals.err = bigintOPdiv_sub(locals.iden, locals.isor, locals.e, locals.quess);
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(452);
        {
        CLUREF T_2_1;
        locals.err = intOPadd(locals.divsofar, locals.quess, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.divsofar.num = T_2_1.num;
        }
        }
        end_while_1:;

  LINE(454);
    {
    {
    ret_1->num = locals.divsofar.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE div_one ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist9 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPdiv_one_actual;
static Vlist1 vals_bigintOPdiv_one = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_bigintOPdiv_one = {0, 0};
static Vlist9 locals_bigintOPdiv_one = {0, 9,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ssz", &int_ops},  {0, 2, "d", &int_ops},  {0, 2, "divsofar", &int_ops},  {0, 2, "quess", &int_ops},  {0, 2, "iden", &array_of_int_ops},  {0, 2, "isor", &array_of_int_ops},  {0, 2, "e", &int_ops}}
};
static Vlist0 popowns_bigintOPdiv_one = {0, 0};
Slist0 tformals_bigintOPdiv_one = {0, 0};
Slist0 opformals_bigintOPdiv_one = {0, 0};
dbg_info_bigintOPdiv_one_actual dbg_info_bigintOPdiv_one_data = {0, 12, 
    "bigintOPdiv_one", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPdiv_one, 3, 
    &vals_bigintOPdiv_one, &sigs_bigintOPdiv_one, &locals_bigintOPdiv_one, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPdiv_one = (struct dbg_info*)&dbg_info_bigintOPdiv_one_data;
extern struct dbg_info* dbg_info_bigintOPdiv_lt;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPdiv_lt_TRACE
int bigintOPdiv_lt_TRACE;
extern errcode bigintOPdiv_lt_IB_1();
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPdiv_lt_own_init = 0;

/**** BEGIN PROCEDURE div_lt ****/

errcode bigintOPdiv_lt(iden, isor, e, ret_1)
CLUREF iden;
CLUREF isor;
CLUREF e;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d;
        CLUREF s;
        CLUREF dd;
        CLUREF ss;
        CLUREF iden;
        CLUREF isor;
        CLUREF e;
        } locals;
    locals.d.num = UNINIT;
    locals.s.num = UNINIT;
    locals.dd.num = UNINIT;
    locals.ss.num = UNINIT;
    locals.iden.num = UNINIT;
    locals.isor.num = UNINIT;
    locals.e.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPdiv_lt;
    locals.iden = iden;
    locals.isor = isor;
    locals.e = e;
        if (bigintOPdiv_lt_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPdiv_lt_own_init = 1;
    }
    enter_proc(458);

  LINE(459);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = locals.isor.array->ext_size;
        locals.err = intOPadd(locals.e, T_1_1, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPsub(T_1_2, CLU_1, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.d.num = T_1_3.num;
        }
        }

  LINE(460);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    locals.err = intOPadd(locals.d, CLU_1, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = arrayOPfetch(locals.iden, T_1_1, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_3.num = (T_1_2.num > 0)? true : false;
    if (T_1_3.num == true) {
        {
        {
        ret_1->tf = false;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(461);
    {
        CLUREF T_1_1;
        CLUREF T_1_2;
        T_1_1.num = locals.isor.array->ext_size;
        T_1_2.num = -1;
        locals.err = intOPfrom_to_by(T_1_1, CLU_1, T_1_2, bigintOPdiv_lt_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        ret_1->num = elist[0].num;
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(467);
    {
    {
    ret_1->tf = false;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE div_lt ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist9 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPdiv_lt_actual;
static Vlist1 vals_bigintOPdiv_lt = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_bigintOPdiv_lt = {0, 0};
static Vlist9 locals_bigintOPdiv_lt = {0, 9,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d", &int_ops},  {0, 2, "s", &int_ops},  {0, 2, "dd", &int_ops},  {0, 2, "ss", &int_ops},  {0, 2, "iden", &array_of_int_ops},  {0, 2, "isor", &array_of_int_ops},  {0, 2, "e", &int_ops}}
};
static Vlist0 popowns_bigintOPdiv_lt = {0, 0};
Slist0 tformals_bigintOPdiv_lt = {0, 0};
Slist0 opformals_bigintOPdiv_lt = {0, 0};
dbg_info_bigintOPdiv_lt_actual dbg_info_bigintOPdiv_lt_data = {0, 12, 
    "bigintOPdiv_lt", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPdiv_lt, 3, 
    &vals_bigintOPdiv_lt, &sigs_bigintOPdiv_lt, &locals_bigintOPdiv_lt, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPdiv_lt = (struct dbg_info*)&dbg_info_bigintOPdiv_lt_data;

/**** BEGIN ITERATOR BODIES for div_lt ****/

errcode bigintOPdiv_lt_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF d;
    CLUREF s;
    CLUREF dd;
    CLUREF ss;
    CLUREF iden;
    CLUREF isor;
    CLUREF e;
    } *locals;
{
    locals->s.num = iv_1.num;
    enter_iter_body_proc(462);

  FB_LINE(462);
    {
        {CLUREF T_1_1;
        locals->err = arrayOPfetch(locals->iden, locals->d, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->dd.num = T_1_1.num;
        }
        }
    {
        {CLUREF T_1_1;
        locals->err = arrayOPfetch(locals->isor, locals->s, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->ss.num = T_1_1.num;
        }
        }

  FB_LINE(463);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals->dd.num < locals->ss.num)? true : false;
    if (T_1_1.num == true) {
        {
        {
        elist[0].tf = true;
        }
        *iecode = ERR_ok;
        {signal(ERR_iterbodyreturn);}
        }
        }
        }/* end if */

  FB_LINE(464);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals->dd.num > locals->ss.num)? true : false;
    if (T_1_1.num == true) {
        {
        {
        elist[0].tf = false;
        }
        *iecode = ERR_ok;
        {signal(ERR_iterbodyreturn);}
        }
        }
        }/* end if */

  FB_LINE(465);
    {
    CLUREF T_1_1;
    locals->err = intOPsub(locals->d, CLU_1, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->d.num = T_1_1.num;
    }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end bigintOPdiv_lt_IB_1 */

/**** END ITERATOR BODIES for div_lt ****/

extern struct dbg_info* dbg_info_bigintOPdiv_sub;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPdiv_sub_TRACE
int bigintOPdiv_sub_TRACE;
extern errcode bigintOPdiv_sub_IB_1();
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPdiv_sub_own_init = 0;

/**** BEGIN PROCEDURE div_sub ****/

errcode bigintOPdiv_sub(iden, isor, e, x)
CLUREF iden;
CLUREF isor;
CLUREF e;
CLUREF x;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF borry;
        CLUREF ss;
        CLUREF psum;
        CLUREF newee;
        CLUREF iden;
        CLUREF isor;
        CLUREF e;
        CLUREF x;
        } locals;
    locals.borry.num = UNINIT;
    locals.ss.num = UNINIT;
    locals.psum.num = UNINIT;
    locals.newee.num = UNINIT;
    locals.iden.num = UNINIT;
    locals.isor.num = UNINIT;
    locals.e.num = UNINIT;
    locals.x.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPdiv_sub;
    locals.iden = iden;
    locals.isor = isor;
    locals.e = e;
    locals.x = x;
        if (bigintOPdiv_sub_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPdiv_sub_own_init = 1;
    }
    enter_proc(471);

  LINE(472);
    {
        {locals.borry.num = 0;
        }
        }

  LINE(473);
    {
        locals.err = arrayOPelements(locals.isor, bigintOPdiv_sub_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(484);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals.borry.num > 0)? true : false;
    if (T_1_1.num == true) {

  LINE(485);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        locals.err = arrayOPfetch(locals.iden, locals.e, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPsub(T_2_1, locals.borry, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = arrayOPstore(locals.iden, locals.e, T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        }
        }
        }/* end if */
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE div_sub ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist10 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPdiv_sub_actual;
static Vlist0 vals_bigintOPdiv_sub = {0, 0};
static siglist0 sigs_bigintOPdiv_sub = {0, 0};
static Vlist10 locals_bigintOPdiv_sub = {0, 10,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "borry", &int_ops},  {0, 2, "ss", &int_ops},  {0, 2, "psum", &int_ops},  {0, 2, "newee", &int_ops},  {0, 2, "iden", &array_of_int_ops},  {0, 2, "isor", &array_of_int_ops},  {0, 2, "e", &int_ops},  {0, 2, "x", &int_ops}}
};
static Vlist0 popowns_bigintOPdiv_sub = {0, 0};
Slist0 tformals_bigintOPdiv_sub = {0, 0};
Slist0 opformals_bigintOPdiv_sub = {0, 0};
dbg_info_bigintOPdiv_sub_actual dbg_info_bigintOPdiv_sub_data = {0, 12, 
    "bigintOPdiv_sub", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPdiv_sub, 4, 
    &vals_bigintOPdiv_sub, &sigs_bigintOPdiv_sub, &locals_bigintOPdiv_sub, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPdiv_sub = (struct dbg_info*)&dbg_info_bigintOPdiv_sub_data;

/**** BEGIN ITERATOR BODIES for div_sub ****/

errcode bigintOPdiv_sub_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF borry;
    CLUREF ss;
    CLUREF psum;
    CLUREF newee;
    CLUREF iden;
    CLUREF isor;
    CLUREF e;
    CLUREF x;
    } *locals;
{
    locals->ss.num = iv_1.num;
    enter_iter_body_proc(474);

  FB_LINE(474);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        locals->err = intOPmul(locals->ss, locals->x, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = intOPadd(locals->borry, T_1_1, &T_1_2);
        if (locals->err != ERR_ok) goto ex_0;
        locals->psum.num = T_1_2.num;
        }
        }

  FB_LINE(475);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        locals->err = arrayOPfetch(locals->iden, locals->e, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        T_1_2.num = 16384;
        locals->err = intOPmod(locals->psum, T_1_2, &T_1_3);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = intOPsub(T_1_1, T_1_3, &T_1_4);
        if (locals->err != ERR_ok) goto ex_0;
        locals->newee.num = T_1_4.num;
        }
        }

  FB_LINE(476);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = 16384;
    locals->err = intOPdiv(locals->psum, T_1_1, &T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    locals->borry.num = T_1_2.num;
    }

  FB_LINE(477);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals->newee.num < 0)? true : false;
    if (T_1_1.num == true) {

  FB_LINE(478);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 16384;
        locals->err = intOPadd(locals->newee, T_2_1, &T_2_2);
        if (locals->err != ERR_ok) goto ex_0;
        locals->newee.num = T_2_2.num;
        }

  FB_LINE(479);
        {
        CLUREF T_2_1;
        locals->err = intOPadd(locals->borry, CLU_1, &T_2_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->borry.num = T_2_1.num;
        }
        }
        }/* end if */

  FB_LINE(481);
    {
    locals->err = arrayOPstore(locals->iden, locals->e, locals->newee);
    if (locals->err != ERR_ok) goto ex_0;
    }

  FB_LINE(482);
    {
    CLUREF T_1_1;
    locals->err = intOPadd(locals->e, CLU_1, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->e.num = T_1_1.num;
    }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end bigintOPdiv_sub_IB_1 */

/**** END ITERATOR BODIES for div_sub ****/

extern struct dbg_info* dbg_info_bigintOPnew_base;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPnew_base_TRACE
int bigintOPnew_base_TRACE;
extern errcode bigintOPnew_base_IB_1();
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPnew_base_own_init = 0;

/**** BEGIN PROCEDURE new_base ****/

errcode bigintOPnew_base(a, ret_1)
CLUREF a;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF r;
        CLUREF adig;
        CLUREF topa;
        CLUREF a;
        } locals;
    locals.r.num = UNINIT;
    locals.adig.num = UNINIT;
    locals.topa.num = UNINIT;
    locals.a.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPnew_base;
    locals.a = a;
        if (bigintOPnew_base_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPnew_base_own_init = 1;
    }
    enter_proc(491);

  LINE(492);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = locals.a.array->ext_size;
        locals.err = intOPmul(CLU_2, T_1_1, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = arrayOPpredict(CLU_1, T_1_2, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.r.num = T_1_3.num;
        }
        }

  LINE(493);
    {
        locals.err = arrayOPelements(locals.a, bigintOPnew_base_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        ret_1->num = elist[0].num;
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(497);
    {
        {CLUREF T_1_1;
        locals.err = arrayOPtop(locals.a, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.topa.num = T_1_1.num;
        }
        }

  LINE(498);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = 134217728;
    T_1_2.num = (locals.topa.num < T_1_1.num)? true : false;
    if (T_1_2.num == true) {

  LINE(499);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 8192;
        T_2_2.num = (locals.topa.num < T_2_1.num)? true : false;
        if (T_2_2.num == true) {
            {
            CLUREF T_3_1;
            locals.err = arrayOPremh(locals.r, &T_3_1);
            if (locals.err != ERR_ok) goto ex_0;
            }
            }
            }/* end if */
        }
    else {

  LINE(502);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 268427265;
        T_2_2.num = (locals.topa.num >= T_2_1.num)? true : false;
        if (T_2_2.num == true) {
            {
            CLUREF T_3_1;
            locals.err = arrayOPremh(locals.r, &T_3_1);
            if (locals.err != ERR_ok) goto ex_0;
            }
            }
            }/* end if */
        }}/* end if */

  LINE(504);
    {
    {
    ret_1->num = locals.r.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE new_base ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist6 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPnew_base_actual;
static Vlist1 vals_bigintOPnew_base = {0, 1, { {0, 2, "", &array_of_int_ops}}
};
static siglist0 sigs_bigintOPnew_base = {0, 0};
static Vlist6 locals_bigintOPnew_base = {0, 6,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "r", &array_of_int_ops},  {0, 2, "adig", &int_ops},  {0, 2, "topa", &int_ops},  {0, 2, "a", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPnew_base = {0, 0};
Slist0 tformals_bigintOPnew_base = {0, 0};
Slist0 opformals_bigintOPnew_base = {0, 0};
dbg_info_bigintOPnew_base_actual dbg_info_bigintOPnew_base_data = {0, 12, 
    "bigintOPnew_base", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPnew_base, 1, 
    &vals_bigintOPnew_base, &sigs_bigintOPnew_base, &locals_bigintOPnew_base, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPnew_base = (struct dbg_info*)&dbg_info_bigintOPnew_base_data;

/**** BEGIN ITERATOR BODIES for new_base ****/

errcode bigintOPnew_base_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF r;
    CLUREF adig;
    CLUREF topa;
    CLUREF a;
    } *locals;
{
    locals->adig.num = iv_1.num;
    enter_iter_body_proc(494);

  FB_LINE(494);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = 16384;
    locals->err = intOPmod(locals->adig, T_1_1, &T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    locals->err = arrayOPaddh(locals->r, T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    }

  FB_LINE(495);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = 16384;
    locals->err = intOPdiv(locals->adig, T_1_1, &T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    locals->err = arrayOPaddh(locals->r, T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end bigintOPnew_base_IB_1 */

/**** END ITERATOR BODIES for new_base ****/

extern struct dbg_info* dbg_info_bigintOPold_base;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPold_base_TRACE
int bigintOPold_base_TRACE;
extern errcode bigintOPold_base_IB_1();
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPold_base_own_init = 0;

/**** BEGIN PROCEDURE old_base ****/

errcode bigintOPold_base(a, ret_1)
CLUREF a;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF rsz;
        CLUREF r;
        CLUREF carry;
        CLUREF i;
        CLUREF ai;
        CLUREF aip1;
        CLUREF nsum;
        CLUREF a;
        } locals;
    locals.rsz.num = UNINIT;
    locals.r.num = UNINIT;
    locals.carry.num = UNINIT;
    locals.i.num = UNINIT;
    locals.ai.num = UNINIT;
    locals.aip1.num = UNINIT;
    locals.nsum.num = UNINIT;
    locals.a.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPold_base;
    locals.a = a;
        if (bigintOPold_base_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPold_base_own_init = 1;
    }
    enter_proc(509);

  LINE(510);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        T_1_1.num = locals.a.array->ext_size;
        locals.err = intOPdiv(T_1_1, CLU_2, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.rsz.num = T_1_2.num;
        }
        }

  LINE(511);
    {
        {CLUREF T_1_1;
        locals.err = arrayOPpredict(CLU_1, locals.rsz, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.r.num = T_1_1.num;
        }
        }

  LINE(512);
    {
        {locals.carry.num = 0;
        }
        }

  LINE(513);
    {
        CLUREF T_1_1;
        T_1_1.num = locals.a.array->ext_size;
        locals.err = intOPfrom_to_by(CLU_1, T_1_1, CLU_2, bigintOPold_base_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        ret_1->num = elist[0].num;
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(533);
    {
    locals.err = bigintOPclear_leads(locals.r);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(534);
    {
    {
    ret_1->num = locals.r.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE old_base ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist10 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPold_base_actual;
static Vlist1 vals_bigintOPold_base = {0, 1, { {0, 2, "", &array_of_int_ops}}
};
static siglist0 sigs_bigintOPold_base = {0, 0};
static Vlist10 locals_bigintOPold_base = {0, 10,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "rsz", &int_ops},  {0, 2, "r", &array_of_int_ops},  {0, 2, "carry", &int_ops},  {0, 2, "i", &int_ops},  {0, 2, "ai", &int_ops},  {0, 2, "aip1", &int_ops},  {0, 2, "nsum", &int_ops},  {0, 2, "a", &array_of_int_ops}}
};
static Vlist0 popowns_bigintOPold_base = {0, 0};
Slist0 tformals_bigintOPold_base = {0, 0};
Slist0 opformals_bigintOPold_base = {0, 0};
dbg_info_bigintOPold_base_actual dbg_info_bigintOPold_base_data = {0, 12, 
    "bigintOPold_base", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPold_base, 1, 
    &vals_bigintOPold_base, &sigs_bigintOPold_base, &locals_bigintOPold_base, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPold_base = (struct dbg_info*)&dbg_info_bigintOPold_base_data;

/**** BEGIN ITERATOR BODIES for old_base ****/

errcode bigintOPold_base_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF rsz;
    CLUREF r;
    CLUREF carry;
    CLUREF i;
    CLUREF ai;
    CLUREF aip1;
    CLUREF nsum;
    CLUREF a;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(514);

  FB_LINE(514);
    {
        {CLUREF T_1_1;
        locals->err = arrayOPfetch(locals->a, locals->i, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->ai.num = T_1_1.num;
        }
        }

  FB_LINE(515);
    {
        {CLUREF T_2_1;
        CLUREF T_2_2;
        locals->err = intOPadd(locals->i, CLU_1, &T_2_1);
        if (locals->err != ERR_ok) goto ex_1;
        locals->err = arrayOPfetch(locals->a, T_2_1, &T_2_2);
        if (locals->err != ERR_ok) goto ex_1;
        locals->aip1.num = T_2_2.num;
        }
        }
        goto end_1;
        ex_1:
            if ((locals->err == ERR_bounds)) {

  FB_LINE(518);
                {
                CLUREF T_2_1;
                CLUREF T_2_2;
                T_2_1.num = 8192;
                T_2_2.num = (locals->ai.num < T_2_1.num)? true : false;
                if (T_2_2.num == true) {

  FB_LINE(519);
                    {
                    locals->aip1.num = 0;
                    }
                    }
                else {

  FB_LINE(521);
                    {
                    locals->aip1.num = 16383;
                    }
                    }}/* end if */
            }
            else {
                goto ex_0;
            }
        end_1:;

  FB_LINE(524);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        CLUREF T_1_5;
        CLUREF T_1_6;
        T_1_1.num = 16384;
        locals->err = intOPmod(locals->aip1, T_1_1, &T_1_2);
        if (locals->err != ERR_ok) goto ex_0;
        T_1_3.num = 16384;
        locals->err = intOPmul(T_1_2, T_1_3, &T_1_4);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = intOPadd(T_1_4, locals->ai, &T_1_5);
        if (locals->err != ERR_ok) goto ex_0;
        locals->err = intOPadd(T_1_5, locals->carry, &T_1_6);
        if (locals->err != ERR_ok) goto ex_0;
        locals->nsum.num = T_1_6.num;
        }
        }

  FB_LINE(525);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = 16384;
    locals->err = intOPdiv(locals->aip1, T_1_1, &T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    locals->carry.num = T_1_2.num;
    }

  FB_LINE(526);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = 268435456;
    T_1_2.num = (locals->nsum.num >= T_1_1.num)? true : false;
    if (T_1_2.num == true) {

  FB_LINE(527);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 268435456;
        locals->err = intOPsub(locals->nsum, T_2_1, &T_2_2);
        if (locals->err != ERR_ok) goto ex_0;
        locals->nsum.num = T_2_2.num;
        }

  FB_LINE(528);
        {
        CLUREF T_2_1;
        locals->err = intOPadd(locals->carry, CLU_1, &T_2_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->carry.num = T_2_1.num;
        }
        }
        }/* end if */

  FB_LINE(530);
    {
    locals->err = arrayOPaddh(locals->r, locals->nsum);
    if (locals->err != ERR_ok) goto ex_0;
    }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end bigintOPold_base_IB_1 */

/**** END ITERATOR BODIES for old_base ****/

extern struct dbg_info* dbg_info_bigintOPdebug_print;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG bigintOPdebug_print_TRACE
int bigintOPdebug_print_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int bigintOPdebug_print_own_init = 0;

/**** BEGIN PROCEDURE debug_print ****/

errcode bigintOPdebug_print(_rep, ps)
CLUREF _rep;
CLUREF ps;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF _rep;
        CLUREF ps;
        } locals;
    locals._rep.num = UNINIT;
    locals.ps.num = UNINIT;
    locals.DBG_INFO = dbg_info_bigintOPdebug_print;
    locals._rep = _rep;
    locals.ps = ps;
        if (bigintOPdebug_print_own_init == 0) {
        if (bigint_own_init == 0) {
            locals.err = bigint_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        bigintOPdebug_print_own_init = 1;
    }
    enter_proc(1);

  LINE(2);
    {
    generic_CLU_proc.type_owns = array_of_int_ops->type_owns;
    generic_CLU_proc.proc = arrayOPdebug_print;
    CUR_PROC_VAR.proc = &generic_CLU_proc;
    locals.err = arrayOPdebug_print(locals._rep, locals.ps);
    if (locals.err != ERR_ok) goto ex_0;
    }
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE debug_print ****/

extern struct OPS *pstream_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist39 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_bigintOPdebug_print_actual;
static Vlist0 vals_bigintOPdebug_print = {0, 0};
static siglist0 sigs_bigintOPdebug_print = {0, 0};
static Vlist4 locals_bigintOPdebug_print = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "_rep", &array_of_int_ops},  {0, 2, "ps", &pstream_ops}}
};
static Vlist0 popowns_bigintOPdebug_print = {0, 0};
Slist0 tformals_bigintOPdebug_print = {0, 0};
Slist0 opformals_bigintOPdebug_print = {0, 0};
dbg_info_bigintOPdebug_print_actual dbg_info_bigintOPdebug_print_data = {0, 12, 
    "bigintOPdebug_print", "/common/pub/dcurtis-temp/pclu/lib/clu/bigint.clu", 0, 0, (int)bigintOPdebug_print, 2, 
    &vals_bigintOPdebug_print, &sigs_bigintOPdebug_print, &locals_bigintOPdebug_print, &owns_bigint, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_bigintOPdebug_print = (struct dbg_info*)&dbg_info_bigintOPdebug_print_data;
typedef struct{
    int count;
    OWNPTR type_owns;
    OWNPTR op_owns;
    struct OP_ENTRY entry[24];
} bigint_OPS;

CLU_proc bigint_oe_abs = {{0,0,0,0}, bigintOPabs, 0};
CLU_proc bigint_oe_add = {{0,0,0,0}, bigintOPadd, 0};
CLU_proc bigint_oe_bi2i = {{0,0,0,0}, bigintOPbi2i, 0};
CLU_proc bigint_oe_copy = {{0,0,0,0}, bigintOPcopy, 0};
CLU_proc bigint_oe_decode = {{0,0,0,0}, bigintOPdecode, 0};
CLU_proc bigint_oe_div = {{0,0,0,0}, bigintOPdiv, 0};
CLU_proc bigint_oe_encode = {{0,0,0,0}, bigintOPencode, 0};
CLU_proc bigint_oe_equal = {{0,0,0,0}, bigintOPequal, 0};
CLU_proc bigint_oe_ge = {{0,0,0,0}, bigintOPge, 0};
CLU_proc bigint_oe_gt = {{0,0,0,0}, bigintOPgt, 0};
CLU_proc bigint_oe_i2bi = {{0,0,0,0}, bigintOPi2bi, 0};
CLU_proc bigint_oe_le = {{0,0,0,0}, bigintOPle, 0};
CLU_proc bigint_oe_lt = {{0,0,0,0}, bigintOPlt, 0};
CLU_proc bigint_oe_max = {{0,0,0,0}, bigintOPmax, 0};
CLU_proc bigint_oe_min = {{0,0,0,0}, bigintOPmin, 0};
CLU_proc bigint_oe_minus = {{0,0,0,0}, bigintOPminus, 0};
CLU_proc bigint_oe_mod = {{0,0,0,0}, bigintOPmod, 0};
CLU_proc bigint_oe_mul = {{0,0,0,0}, bigintOPmul, 0};
CLU_proc bigint_oe_parse = {{0,0,0,0}, bigintOPparse, 0};
CLU_proc bigint_oe_power = {{0,0,0,0}, bigintOPpower, 0};
CLU_proc bigint_oe_similar = {{0,0,0,0}, bigintOPsimilar, 0};
CLU_proc bigint_oe_sub = {{0,0,0,0}, bigintOPsub, 0};
CLU_proc bigint_oe_unparse = {{0,0,0,0}, bigintOPunparse, 0};
CLU_proc bigint_oe_debug_print = {{0,0,0,0}, bigintOPdebug_print, 0};

bigint_OPS bigint_ops_actual = {24, (OWNPTR)&bigint_own_init, (OWNPTR)&bigint_own_init, {
    {&bigint_oe_abs, "abs"},
    {&bigint_oe_add, "add"},
    {&bigint_oe_bi2i, "bi2i"},
    {&bigint_oe_copy, "copy"},
    {&bigint_oe_decode, "decode"},
    {&bigint_oe_div, "div"},
    {&bigint_oe_encode, "encode"},
    {&bigint_oe_equal, "equal"},
    {&bigint_oe_ge, "ge"},
    {&bigint_oe_gt, "gt"},
    {&bigint_oe_i2bi, "i2bi"},
    {&bigint_oe_le, "le"},
    {&bigint_oe_lt, "lt"},
    {&bigint_oe_max, "max"},
    {&bigint_oe_min, "min"},
    {&bigint_oe_minus, "minus"},
    {&bigint_oe_mod, "mod"},
    {&bigint_oe_mul, "mul"},
    {&bigint_oe_parse, "parse"},
    {&bigint_oe_power, "power"},
    {&bigint_oe_similar, "similar"},
    {&bigint_oe_sub, "sub"},
    {&bigint_oe_unparse, "unparse"},
    {&bigint_oe_debug_print, "debug_print"}}};

struct OPS *bigint_ops = (struct OPS *)&bigint_ops_actual;

/**** END CLUSTER bigint ****/