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

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


/**** BEGIN CLUSTER table ****/


typedef struct {
int count;
} table_of_key_REQS;

table_of_key_REQS table_of_key_reqs_actual = {0};

struct REQS * table_of_key_reqs = (struct REQS *)&table_of_key_reqs_actual;


typedef struct {
    int count;
    OWNPTR type_owns;
    OWNPTR op_owns;
    } table_of_key_OPS;


typedef struct {
int count;
} table_of_val_REQS;

table_of_val_REQS table_of_val_reqs_actual = {0};

struct REQS * table_of_val_reqs = (struct REQS *)&table_of_val_reqs_actual;


typedef struct {
    int count;
    OWNPTR type_owns;
    OWNPTR op_owns;
    } table_of_val_OPS;

extern errcode table_IB_1();
extern errcode table_IB_2();
extern errcode table_IB_3();
extern errcode table_IB_4();
extern errcode table_IB_5();
extern errcode table_IB_6();
extern errcode table_IB_7();
extern errcode table_IB_8();
extern errcode intOPlt();
extern errcode _objOPequal();
extern errcode _cvt();
extern errcode _vecOPcreate();
extern errcode recordOPset_5();
extern errcode recordOPget_1();
extern errcode intOPfrom_to();
extern errcode recordOPget_7();
extern errcode _vecOPstore();
extern errcode _vecOPfetch();
extern errcode boolOPnot();
extern errcode recordOPget_2();
extern errcode recordOPget_3();
extern errcode recordOPset_2();
extern errcode recordOPget_5();
extern errcode recordOPset_4();
extern errcode intOPadd();
extern errcode recordOPget_6();
extern errcode recordOPget_4();
extern errcode recordOPset_6();
extern errcode recordOPset_3();
extern errcode arrayOPcreate();
extern errcode arrayOPstore();
extern errcode arrayOPfetch();
extern errcode arrayOPsize();
extern errcode arrayOPaddh();
extern errcode recordOPdebug_print();
extern OWN_req int_ownreqs;
extern struct OPS *int_ops;
extern struct REQS *_vec_of_t_reqs;
extern struct OPS *null_ops;
extern OWN_req _vec_ownreqs;
extern struct OPS *_vec_ops;
struct OPS *_vec_of_null_table;
struct OPS *_vec_of_null_ops;
struct OPS *_vec_of_null_ops;
OWNPTR _vec_of_null_owns;
extern struct OPS *_obj_ops;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
extern struct OPS *_vec_of__obj_ops;
extern struct OPS *proctype_ops;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_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;

OWN_ptr table_own_init; /* dummy */
typedef struct {
    int table_own_init;
    CLUREF unique;
    int create_own_init;
    int flush_own_init;
    int cond_flush_own_init;
    int bind_own_init;
    int mbind_own_init;
    int alter_own_init;
    int lookup_own_init;
    int mlookup_own_init;
    int get_pair_own_init;
    int exists_own_init;
    int remove_own_init;
    int delete_own_init;
    int rehash_own_init;
    int elements_own_init;
    int count_own_init;
    int empty_own_init;
    int sizes_own_init;
    int debug_print_own_init;
    table_of_key_OPS *key_ops;
    table_of_val_OPS *val_ops;
    struct OPS  *record_key_next_val_1_ops;
} table_OWN_DEFN;

OWN_req table_ownreqs = {sizeof(table_OWN_DEFN), 20};

errcode table_own_init_proc()
{
struct {
errcode err;
table_OWN_DEFN *type_own_ptr;} locals;
locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;

enter_own_init_proc();
    if (locals.type_own_ptr->table_own_init == 0) {
    add_parm_info_type(0, null_ops, _vec_of_t_reqs);
    find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of_null_ops));
    add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
    find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
    add_selector_info("buckets", 0, _vec_of__obj_ops); 
    add_selector_info("comper", 1, proctype_ops); 
    add_selector_info("hasher", 2, proctype_ops); 
    add_selector_info("lhash", 3, int_ops); 
    add_selector_info("lkey", 4, _obj_ops); 
    add_selector_info("lval", 5, _obj_ops); 
    add_selector_info("size", 6, int_ops); 
    find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
    add_parm_info_type(0, int_ops, array_of_t_reqs);
    find_type_instance(array_ops, 1, &array_ownreqs, &(array_of_int_ops));
    add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
    add_selector_info("next", 1, _obj_ops); 
    add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
    find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
    }
    if (locals.type_own_ptr->table_own_init == 0) {
    locals.type_own_ptr->table_own_init = 1;
    locals.type_own_ptr->unique.num = UNINIT;
    {signal(ERR_ok);}
    ex_0: pclu_unhandled(locals.err); {signal(ERR_failure);}
}
}

extern struct dbg_info* dbg_info_tableOPcreate;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPcreate_TRACE
int tableOPcreate_TRACE;
static Vlist23 ptowns_table = {0, 23,{ {0, 2, "table_init", &int_ops}
,  {0, 2, "unique", &_obj_ops}, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
, {0, 2, "tableOPcreate_init", &int_ops}
,{0, 2, "key_ops", &int_ops}
,{0, 2, "val_ops", &int_ops}
,{0, 2, "record_key_next_val_1_ops", &int_ops}
}};
struct OPS *_vec_of_null_table;
struct OPS *_vec_of_null_ops;
struct OPS *_vec_of_null_ops;
OWNPTR _vec_of_null_owns;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE create ****/

errcode tableOPcreate(size, hasher, comper, ret_1)
CLUREF size;
CLUREF hasher;
CLUREF comper;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF size;
        CLUREF hasher;
        CLUREF comper;
        } locals;
    locals.size.num = UNINIT;
    locals.hasher.num = UNINIT;
    locals.comper.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPcreate;
    locals.size = size;
    locals.hasher = hasher;
    locals.comper = comper;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->create_own_init == 0) {
        add_parm_info_type(0, null_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of_null_ops));
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->create_own_init == 0) {
        locals.type_own_ptr->create_own_init = 1;
    }
    enter_proc(42);

  LINE(44);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals.size.num < 1)? true : false;
    if (T_1_1.num == true) {

  LINE(45);
        {
        {signal (ERR_bad_size);}}
        }
        }/* end if */

  LINE(46);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = nil;
    T_1_2.num = (locals.type_own_ptr->unique.num == T_1_1.num)? true : false;
    if (T_1_2.num == true) {

  LINE(47);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        locals.err = _vecOPcreate(CLU_0, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        T_2_2.num = T_2_1.num;
        locals.type_own_ptr->unique.num = T_2_2.num;
        }
        }
        }/* end if */

  LINE(48);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    RecordAlloc(7, T_1_1);
    T_1_1.vec->data[6]  = locals.size.num;
    T_1_1.vec->data[2]  = locals.hasher.num;
    T_1_1.vec->data[1]  = locals.comper.num;
    T_1_1.vec->data[4]  = locals.type_own_ptr->unique.num;
    T_1_1.vec->data[3]  = 0;
    T_1_1.vec->data[5]  = locals.type_own_ptr->unique.num;
    locals.err = _vecOPcreate(locals.size, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_1.vec->data[0]  = T_1_2.num;
    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 create ****/

extern struct OPS *record_buckets_comper_hasher_lhash_lkey_lval_size_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;
    Vlist6 *locals;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPcreate_actual;
static Vlist1 vals_tableOPcreate = {0, 1, { {0, 2, "", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops}}
};
static sig_desc0 sig_tableOPcreate_1 = {0, 3, "bad_size", {0, 0
}};
static siglist1 sigs_tableOPcreate = {0, 1, (sig_desc*)&sig_tableOPcreate_1};
static Vlist6 locals_tableOPcreate = {0, 6,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "size", &int_ops},  {0, 2, "hasher", m1_ops},  {0, 2, "comper", m1_ops}}
};
static Vlist0 popowns_tableOPcreate = {0, 0};
Slist2 tformals_tableOPcreate = {0, 2, "key", "val"};
Slist0 opformals_tableOPcreate = {0, 0};
dbg_info_tableOPcreate_actual dbg_info_tableOPcreate_data = {0, 12, 
    "tableOPcreate", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPcreate, 3, 
    &vals_tableOPcreate, &sigs_tableOPcreate, &locals_tableOPcreate, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPcreate, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPcreate = (struct dbg_info*)&dbg_info_tableOPcreate_data;
extern struct dbg_info* dbg_info_tableOPflush;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPflush_TRACE
int tableOPflush_TRACE;
extern errcode tableOPflush_IB_1();
extern OWN_req _obj_ownreqs;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE flush ****/

errcode tableOPflush(t)
CLUREF t;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF bucks;
        CLUREF i;
        CLUREF t;
        } locals;
    locals.bucks.num = UNINIT;
    locals.i.num = UNINIT;
    locals.t.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPflush;
    locals.t = t;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->flush_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->flush_own_init == 0) {
        locals.type_own_ptr->flush_own_init = 1;
    }
    enter_proc(59);

  LINE(60);
    {
    locals.t.vec->data[4]  = locals.type_own_ptr->unique.num;
    }

  LINE(61);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[0];
        locals.bucks.num = T_1_1.num;
        }
        }

  LINE(62);
    {
        CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[6];
        locals.err = intOPfrom_to(CLU_1, T_1_1, tableOPflush_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 flush ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist6 *locals;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPflush_actual;
static Vlist0 vals_tableOPflush = {0, 0};
static siglist0 sigs_tableOPflush = {0, 0};
static Vlist6 locals_tableOPflush = {0, 6,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "bucks", &_vec_of__obj_ops},  {0, 2, "i", &int_ops},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops}}
};
static Vlist0 popowns_tableOPflush = {0, 0};
Slist2 tformals_tableOPflush = {0, 2, "key", "val"};
Slist0 opformals_tableOPflush = {0, 0};
dbg_info_tableOPflush_actual dbg_info_tableOPflush_data = {0, 12, 
    "tableOPflush", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPflush, 1, 
    &vals_tableOPflush, &sigs_tableOPflush, &locals_tableOPflush, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPflush, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPflush = (struct dbg_info*)&dbg_info_tableOPflush_data;

/**** BEGIN ITERATOR BODIES for flush ****/

errcode tableOPflush_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
table_OWN_DEFN *type_own_ptr;
    CLUREF bucks;
    CLUREF i;
    CLUREF t;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(63);

  FB_LINE(63);
    {
    CLUREF T_1_1;
    T_1_1.num = nil;
    locals->err = _vecOPstore(locals->bucks, locals->i, 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 tableOPflush_IB_1 */

/**** END ITERATOR BODIES for flush ****/

extern struct dbg_info* dbg_info_tableOPcond_flush;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPcond_flush_TRACE
int tableOPcond_flush_TRACE;
extern errcode tableOPcond_flush_IB_1();
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE cond_flush ****/

errcode tableOPcond_flush(t, pred)
CLUREF t;
CLUREF pred;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF bucks;
        CLUREF i;
        CLUREF lbuck;
        CLUREF isprev;
        CLUREF mb;
        CLUREF buck;
        CLUREF t;
        CLUREF pred;
        } locals;
    locals.bucks.num = UNINIT;
    locals.i.num = UNINIT;
    locals.lbuck.num = UNINIT;
    locals.isprev.num = UNINIT;
    locals.mb.num = UNINIT;
    locals.buck.num = UNINIT;
    locals.t.num = UNINIT;
    locals.pred.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPcond_flush;
    locals.t = t;
    locals.pred = pred;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->cond_flush_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
        find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->cond_flush_own_init == 0) {
        locals.type_own_ptr->cond_flush_own_init = 1;
    }
    enter_proc(69);

  LINE(70);
    {
    locals.t.vec->data[4]  = locals.type_own_ptr->unique.num;
    }

  LINE(71);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[0];
        locals.bucks.num = T_1_1.num;
        }
        }

  LINE(72);
    {
        CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[6];
        locals.err = intOPfrom_to(CLU_1, T_1_1, tableOPcond_flush_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 cond_flush ****/

extern struct OPS *bool_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;
    Vlist11 *locals;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPcond_flush_actual;
static Vlist0 vals_tableOPcond_flush = {0, 0};
static siglist0 sigs_tableOPcond_flush = {0, 0};
static Vlist11 locals_tableOPcond_flush = {0, 11,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "bucks", &_vec_of__obj_ops},  {0, 2, "i", &int_ops},  {0, 2, "lbuck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "isprev", &bool_ops},  {0, 2, "mb", &_obj_ops},  {0, 2, "buck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops},  {0, 2, "pred", m1_ops}}
};
static Vlist0 popowns_tableOPcond_flush = {0, 0};
Slist2 tformals_tableOPcond_flush = {0, 2, "key", "val"};
Slist0 opformals_tableOPcond_flush = {0, 0};
dbg_info_tableOPcond_flush_actual dbg_info_tableOPcond_flush_data = {0, 12, 
    "tableOPcond_flush", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPcond_flush, 2, 
    &vals_tableOPcond_flush, &sigs_tableOPcond_flush, &locals_tableOPcond_flush, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPcond_flush, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPcond_flush = (struct dbg_info*)&dbg_info_tableOPcond_flush_data;

/**** BEGIN ITERATOR BODIES for cond_flush ****/

errcode tableOPcond_flush_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
table_OWN_DEFN *type_own_ptr;
    CLUREF bucks;
    CLUREF i;
    CLUREF lbuck;
    CLUREF isprev;
    CLUREF mb;
    CLUREF buck;
    CLUREF t;
    CLUREF pred;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(73);

  FB_LINE(73);
    locals->lbuck.num = UNINIT;

  FB_LINE(74);
    {
        {locals->isprev.tf = false;
        }
        }

  FB_LINE(75);
    {
        {CLUREF T_1_1;
        locals->err = _vecOPfetch(locals->bucks, locals->i, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->mb.num = T_1_1.num;
        }
        }

  FB_LINE(76);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = nil;
        T_1_2.num = (locals->mb.num == T_1_1.num)? true : false;
        T_1_3.num = T_1_2.num ^ 1;
        if (T_1_3.num != true) { break; }

  FB_LINE(77);
        {
            {CLUREF T_2_1;
            T_2_1.num = locals->mb.num;
            locals->buck.num = T_2_1.num;
            }
            }

  FB_LINE(78);
        {
        CLUREF T_2_1;
        T_2_1.num = locals->buck.vec->data[1];
        locals->mb.num = T_2_1.num;
        }

  FB_LINE(79);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals->buck.vec->data[2];
        CUR_PROC_VAR = locals->pred;
        locals->err = locals->pred.proc->proc(T_2_1, &T_2_2);
        if (locals->err != ERR_ok) goto ex_0;
        if (T_2_2.num == true) {

  FB_LINE(80);
            {
            if (locals->isprev.num == true) {

  FB_LINE(81);
                {
                locals->lbuck.vec->data[1]  = locals->mb.num;
                }
                }
            else {

  FB_LINE(82);
                {
                locals->err = _vecOPstore(locals->bucks, locals->i, locals->mb);
                if (locals->err != ERR_ok) goto ex_0;
                }
                }}/* end if */
            }
        else {

  FB_LINE(84);
            {
            locals->lbuck.num = locals->buck.num;
            }

  FB_LINE(85);
            {
            locals->isprev.tf = true;
            }
            }}/* end if */
        }
        end_while_1:;
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end tableOPcond_flush_IB_1 */

/**** END ITERATOR BODIES for cond_flush ****/

extern struct dbg_info* dbg_info_tableOPpcond_flush;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPpcond_flush_TRACE
int tableOPpcond_flush_TRACE;

typedef struct {
int count;
} table_op_pcond_flush_of_u_REQS;

table_op_pcond_flush_of_u_REQS table_op_pcond_flush_of_u_reqs_actual = {0};

struct REQS * table_op_pcond_flush_of_u_reqs = (struct REQS *)&table_op_pcond_flush_of_u_reqs_actual;


typedef struct {
    int count;
    OWNPTR type_owns;
    OWNPTR op_owns;
    } table_op_pcond_flush_of_u_OPS;

extern errcode tableOPpcond_flush_IB_1();
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

typedef struct {
    int pcond_flush_own_init;
    table_op_pcond_flush_of_u_OPS *u_ops;
    struct OPS  *record_key_next_val_1_ops;
    } table_op_pcond_flush_OWN_DEFN;
OWN_req table_op_pcond_flush_ownreqs = {sizeof(table_op_pcond_flush_OWN_DEFN), 1};


/**** BEGIN PROCEDURE pcond_flush ****/

errcode tableOPpcond_flush(t, pred, thing)
CLUREF t;
CLUREF pred;
CLUREF thing;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        table_op_pcond_flush_OWN_DEFN *op_own_ptr;
        CLUREF bucks;
        CLUREF i;
        CLUREF lbuck;
        CLUREF isprev;
        CLUREF mb;
        CLUREF buck;
        CLUREF t;
        CLUREF pred;
        CLUREF thing;
        } locals;
    locals.bucks.num = UNINIT;
    locals.i.num = UNINIT;
    locals.lbuck.num = UNINIT;
    locals.isprev.num = UNINIT;
    locals.mb.num = UNINIT;
    locals.buck.num = UNINIT;
    locals.t.num = UNINIT;
    locals.pred.num = UNINIT;
    locals.thing.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPpcond_flush;
    locals.t = t;
    locals.pred = pred;
    locals.thing = thing;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
    locals.op_own_ptr = (table_op_pcond_flush_OWN_DEFN*) CUR_PROC_VAR.proc->op_owns;
        if (locals.op_own_ptr->pcond_flush_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
        find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.op_own_ptr->pcond_flush_own_init == 0) {
        locals.op_own_ptr->pcond_flush_own_init = 1;
    }
    enter_proc(93);

  LINE(95);
    {
    locals.t.vec->data[4]  = locals.type_own_ptr->unique.num;
    }

  LINE(96);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[0];
        locals.bucks.num = T_1_1.num;
        }
        }

  LINE(97);
    {
        CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[6];
        locals.err = intOPfrom_to(CLU_1, T_1_1, tableOPpcond_flush_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 pcond_flush ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist13 *locals;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist8 *popowns;
    Slist2 *type_formals;
    Slist1 *op_formals;
    } dbg_info_tableOPpcond_flush_actual;
static Vlist0 vals_tableOPpcond_flush = {0, 0};
static siglist0 sigs_tableOPpcond_flush = {0, 0};
static Vlist13 locals_tableOPpcond_flush = {0, 13,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "op_own_ptr", &int_ops},  {0, 2, "bucks", &_vec_of__obj_ops},  {0, 2, "i", &int_ops},  {0, 2, "lbuck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "isprev", &bool_ops},  {0, 2, "mb", &_obj_ops},  {0, 2, "buck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops},  {0, 2, "pred", m1_ops},  {0, 2, "thing", zero_ops, "u_ops"}}
};
static Vlist8 popowns_tableOPpcond_flush = {0, 8,{ {0, 2, "tableOPpcond_flush_init", &int_ops}
, {0, 2, "_vec_of__obj_table", &NULL_OPS}, {0, 2, "_vec_of__obj_ops", &NULL_OPS}, {0, 2, "_vec_of__obj_ops", &NULL_OPS}, {0, 2, "_vec_of__obj_owns", &NULL_OPS}, {0, 2, "record_buckets_comper_hasher_lhash_lkey_lval_size_ops", &NULL_OPS}, {0, 2, "u_ops", &NULL_OPS}, {0, 2, "record_key_next_val_1_ops", &NULL_OPS}}};
Slist2 tformals_tableOPpcond_flush = {0, 2, "key", "val"};
Slist1 opformals_tableOPpcond_flush = {0, 1, "u"};
dbg_info_tableOPpcond_flush_actual dbg_info_tableOPpcond_flush_data = {0, 12, 
    "tableOPpcond_flush", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 3, (int)tableOPpcond_flush, 3, 
    &vals_tableOPpcond_flush, &sigs_tableOPpcond_flush, &locals_tableOPpcond_flush, &NO_VALS, &ptowns_table, &popowns_tableOPpcond_flush, &tformals_tableOPpcond_flush, &opformals_tableOPpcond_flush};
    struct dbg_info *dbg_info_tableOPpcond_flush = (struct dbg_info*)&dbg_info_tableOPpcond_flush_data;

/**** BEGIN ITERATOR BODIES for pcond_flush ****/

errcode tableOPpcond_flush_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
table_OWN_DEFN *type_own_ptr;
table_op_pcond_flush_OWN_DEFN *op_own_ptr;
    CLUREF bucks;
    CLUREF i;
    CLUREF lbuck;
    CLUREF isprev;
    CLUREF mb;
    CLUREF buck;
    CLUREF t;
    CLUREF pred;
    CLUREF thing;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(98);

  FB_LINE(98);
    locals->lbuck.num = UNINIT;

  FB_LINE(99);
    {
        {locals->isprev.tf = false;
        }
        }

  FB_LINE(100);
    {
        {CLUREF T_1_1;
        locals->err = _vecOPfetch(locals->bucks, locals->i, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->mb.num = T_1_1.num;
        }
        }

  FB_LINE(101);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = nil;
        T_1_2.num = (locals->mb.num == T_1_1.num)? true : false;
        T_1_3.num = T_1_2.num ^ 1;
        if (T_1_3.num != true) { break; }

  FB_LINE(102);
        {
            {CLUREF T_2_1;
            T_2_1.num = locals->mb.num;
            locals->buck.num = T_2_1.num;
            }
            }

  FB_LINE(103);
        {
        CLUREF T_2_1;
        T_2_1.num = locals->buck.vec->data[1];
        locals->mb.num = T_2_1.num;
        }

  FB_LINE(104);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals->buck.vec->data[2];
        CUR_PROC_VAR = locals->pred;
        locals->err = locals->pred.proc->proc(T_2_1, locals->thing, &T_2_2);
        if (locals->err != ERR_ok) goto ex_0;
        if (T_2_2.num == true) {

  FB_LINE(105);
            {
            if (locals->isprev.num == true) {

  FB_LINE(106);
                {
                locals->lbuck.vec->data[1]  = locals->mb.num;
                }
                }
            else {

  FB_LINE(107);
                {
                locals->err = _vecOPstore(locals->bucks, locals->i, locals->mb);
                if (locals->err != ERR_ok) goto ex_0;
                }
                }}/* end if */
            }
        else {

  FB_LINE(109);
            {
            locals->lbuck.num = locals->buck.num;
            }

  FB_LINE(110);
            {
            locals->isprev.tf = true;
            }
            }}/* end if */
        }
        end_while_1:;
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end tableOPpcond_flush_IB_1 */

/**** END ITERATOR BODIES for pcond_flush ****/

extern struct dbg_info* dbg_info_tableOPbind;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPbind_TRACE
int tableOPbind_TRACE;
extern OWN_req bool_ownreqs;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE bind ****/

errcode tableOPbind(t, k, v)
CLUREF t;
CLUREF k;
CLUREF v;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF comper;
        CLUREF xmb;
        CLUREF mb;
        CLUREF buck;
        CLUREF t;
        CLUREF k;
        CLUREF v;
        } locals;
    locals.comper.num = UNINIT;
    locals.xmb.num = UNINIT;
    locals.mb.num = UNINIT;
    locals.buck.num = UNINIT;
    locals.t.num = UNINIT;
    locals.k.num = UNINIT;
    locals.v.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPbind;
    locals.t = t;
    locals.k = k;
    locals.v = v;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->bind_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
        find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->bind_own_init == 0) {
        locals.type_own_ptr->bind_own_init = 1;
    }
    enter_proc(118);

  LINE(119);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.t.vec->data[4];
    T_1_2.num = locals.k.num;
    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) {

  LINE(120);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        T_2_1.num = locals.t.vec->data[6];
        T_2_3.num = locals.t.vec->data[2];
        CUR_PROC_VAR = T_2_3;
        locals.err = T_2_3.proc->proc(locals.k, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPadd(T_2_2, CLU_1, &T_2_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.t.vec->data[3]  = T_2_4.num;
        }
        }
    else {
    CLUREF T_1_5;
    CLUREF T_1_6;
    CLUREF T_1_7;
    T_1_5.num = locals.t.vec->data[5];
    T_1_6.num = (T_1_5.num == locals.type_own_ptr->unique.num)? true : false;
    T_1_7.num = T_1_6.num ^ 1;
    if (T_1_7.num == true) {

  LINE(122);
        {
        {signal (ERR_exists);}}
        }
        }}/* end if */

  LINE(123);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[1];
        locals.comper.num = T_1_1.num;
        }
        }

  LINE(124);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = locals.t.vec->data[0];
        T_1_2.num = locals.t.vec->data[3];
        locals.err = _vecOPfetch(T_1_1, T_1_2, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.xmb.num = T_1_3.num;
        }
        }

  LINE(125);
    {
        {locals.mb.num = locals.xmb.num;
        }
        }

  LINE(126);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = nil;
        T_1_2.num = (locals.mb.num == T_1_1.num)? true : false;
        T_1_3.num = T_1_2.num ^ 1;
        if (T_1_3.num != true) { break; }

  LINE(127);
        {
            {CLUREF T_2_1;
            T_2_1.num = locals.mb.num;
            locals.buck.num = T_2_1.num;
            }
            }

  LINE(128);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.buck.vec->data[0];
        CUR_PROC_VAR = locals.comper;
        locals.err = locals.comper.proc->proc(locals.k, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        if (T_2_2.num == true) {

  LINE(129);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.buck.vec->data[0];
            T_3_2.num = T_3_1.num;
            locals.t.vec->data[4]  = T_3_2.num;
            }

  LINE(130);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.buck.vec->data[2];
            T_3_2.num = T_3_1.num;
            locals.t.vec->data[5]  = T_3_2.num;
            }

  LINE(131);
            {
            {signal (ERR_exists);}}
            }
            }/* end if */

  LINE(133);
        {
        CLUREF T_2_1;
        T_2_1.num = locals.buck.vec->data[1];
        locals.mb.num = T_2_1.num;
        }
        }
        end_while_1:;

  LINE(135);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.k.num;
    locals.t.vec->data[4]  = T_1_1.num;
    }

  LINE(136);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.v.num;
    locals.t.vec->data[5]  = T_1_1.num;
    }

  LINE(137);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.t.vec->data[0];
    T_1_2.num = locals.t.vec->data[3];
    RecordAlloc(3, T_1_3);
    T_1_3.vec->data[0]  = locals.k.num;
    T_1_3.vec->data[2]  = locals.v.num;
    T_1_3.vec->data[1]  = locals.xmb.num;
    T_1_4.num = T_1_3.num;
    locals.err = _vecOPstore(T_1_1, T_1_2, T_1_4);
    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 bind ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist1 *sigs;
    Vlist10 *locals;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPbind_actual;
static Vlist0 vals_tableOPbind = {0, 0};
static sig_desc0 sig_tableOPbind_1 = {0, 3, "exists", {0, 0
}};
static siglist1 sigs_tableOPbind = {0, 1, (sig_desc*)&sig_tableOPbind_1};
static Vlist10 locals_tableOPbind = {0, 10,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "comper", m1_ops},  {0, 2, "xmb", &_obj_ops},  {0, 2, "mb", &_obj_ops},  {0, 2, "buck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops},  {0, 2, "k", zero_ops, "key_ops"},  {0, 2, "v", zero_ops, "val_ops"}}
};
static Vlist0 popowns_tableOPbind = {0, 0};
Slist2 tformals_tableOPbind = {0, 2, "key", "val"};
Slist0 opformals_tableOPbind = {0, 0};
dbg_info_tableOPbind_actual dbg_info_tableOPbind_data = {0, 12, 
    "tableOPbind", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPbind, 3, 
    &vals_tableOPbind, &sigs_tableOPbind, &locals_tableOPbind, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPbind, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPbind = (struct dbg_info*)&dbg_info_tableOPbind_data;
extern struct dbg_info* dbg_info_tableOPmbind;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPmbind_TRACE
int tableOPmbind_TRACE;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE mbind ****/

errcode tableOPmbind(t, k, v, ret_1)
CLUREF t;
CLUREF k;
CLUREF v;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF comper;
        CLUREF xmb;
        CLUREF mb;
        CLUREF buck;
        CLUREF t;
        CLUREF k;
        CLUREF v;
        } locals;
    locals.comper.num = UNINIT;
    locals.xmb.num = UNINIT;
    locals.mb.num = UNINIT;
    locals.buck.num = UNINIT;
    locals.t.num = UNINIT;
    locals.k.num = UNINIT;
    locals.v.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPmbind;
    locals.t = t;
    locals.k = k;
    locals.v = v;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->mbind_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
        find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->mbind_own_init == 0) {
        locals.type_own_ptr->mbind_own_init = 1;
    }
    enter_proc(144);

  LINE(145);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.t.vec->data[4];
    T_1_2.num = locals.k.num;
    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) {

  LINE(146);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        T_2_1.num = locals.t.vec->data[6];
        T_2_3.num = locals.t.vec->data[2];
        CUR_PROC_VAR = T_2_3;
        locals.err = T_2_3.proc->proc(locals.k, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPadd(T_2_2, CLU_1, &T_2_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.t.vec->data[3]  = T_2_4.num;
        }
        }
    else {
    CLUREF T_1_5;
    CLUREF T_1_6;
    CLUREF T_1_7;
    T_1_5.num = locals.t.vec->data[5];
    T_1_6.num = (T_1_5.num == locals.type_own_ptr->unique.num)? true : false;
    T_1_7.num = T_1_6.num ^ 1;
    if (T_1_7.num == true) {

  LINE(148);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.t.vec->data[5];
        T_2_2.num = T_2_1.num;
        ret_1->num = T_2_2.num;
        }
        {signal (ERR_ok);}}
        }
        }}/* end if */

  LINE(149);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[1];
        locals.comper.num = T_1_1.num;
        }
        }

  LINE(150);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = locals.t.vec->data[0];
        T_1_2.num = locals.t.vec->data[3];
        locals.err = _vecOPfetch(T_1_1, T_1_2, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.xmb.num = T_1_3.num;
        }
        }

  LINE(151);
    {
        {locals.mb.num = locals.xmb.num;
        }
        }

  LINE(152);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = nil;
        T_1_2.num = (locals.mb.num == T_1_1.num)? true : false;
        T_1_3.num = T_1_2.num ^ 1;
        if (T_1_3.num != true) { break; }

  LINE(153);
        {
            {CLUREF T_2_1;
            T_2_1.num = locals.mb.num;
            locals.buck.num = T_2_1.num;
            }
            }

  LINE(154);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.buck.vec->data[0];
        CUR_PROC_VAR = locals.comper;
        locals.err = locals.comper.proc->proc(locals.k, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        if (T_2_2.num == true) {

  LINE(155);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.buck.vec->data[0];
            T_3_2.num = T_3_1.num;
            locals.t.vec->data[4]  = T_3_2.num;
            }

  LINE(156);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.buck.vec->data[2];
            T_3_2.num = T_3_1.num;
            locals.t.vec->data[5]  = T_3_2.num;
            }

  LINE(157);
            {
            {
            CLUREF T_3_1;
            T_3_1.num = locals.buck.vec->data[2];
            ret_1->num = T_3_1.num;
            }
            {signal (ERR_ok);}}
            }
            }/* end if */

  LINE(159);
        {
        CLUREF T_2_1;
        T_2_1.num = locals.buck.vec->data[1];
        locals.mb.num = T_2_1.num;
        }
        }
        end_while_1:;

  LINE(161);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.k.num;
    locals.t.vec->data[4]  = T_1_1.num;
    }

  LINE(162);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.v.num;
    locals.t.vec->data[5]  = T_1_1.num;
    }

  LINE(163);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.t.vec->data[0];
    T_1_2.num = locals.t.vec->data[3];
    RecordAlloc(3, T_1_3);
    T_1_3.vec->data[0]  = locals.k.num;
    T_1_3.vec->data[2]  = locals.v.num;
    T_1_3.vec->data[1]  = locals.xmb.num;
    T_1_4.num = T_1_3.num;
    locals.err = _vecOPstore(T_1_1, T_1_2, T_1_4);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(166);
    {
    {
    ret_1->num = locals.v.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 mbind ****/

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;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPmbind_actual;
static Vlist1 vals_tableOPmbind = {0, 1, { {0, 2, "", zero_ops, "val_ops"}}
};
static siglist0 sigs_tableOPmbind = {0, 0};
static Vlist10 locals_tableOPmbind = {0, 10,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "comper", m1_ops},  {0, 2, "xmb", &_obj_ops},  {0, 2, "mb", &_obj_ops},  {0, 2, "buck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops},  {0, 2, "k", zero_ops, "key_ops"},  {0, 2, "v", zero_ops, "val_ops"}}
};
static Vlist0 popowns_tableOPmbind = {0, 0};
Slist2 tformals_tableOPmbind = {0, 2, "key", "val"};
Slist0 opformals_tableOPmbind = {0, 0};
dbg_info_tableOPmbind_actual dbg_info_tableOPmbind_data = {0, 12, 
    "tableOPmbind", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPmbind, 3, 
    &vals_tableOPmbind, &sigs_tableOPmbind, &locals_tableOPmbind, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPmbind, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPmbind = (struct dbg_info*)&dbg_info_tableOPmbind_data;
extern struct dbg_info* dbg_info_tableOPalter;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPalter_TRACE
int tableOPalter_TRACE;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE alter ****/

errcode tableOPalter(t, k, v)
CLUREF t;
CLUREF k;
CLUREF v;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF comper;
        CLUREF xmb;
        CLUREF mb;
        CLUREF buck;
        CLUREF t;
        CLUREF k;
        CLUREF v;
        } locals;
    locals.comper.num = UNINIT;
    locals.xmb.num = UNINIT;
    locals.mb.num = UNINIT;
    locals.buck.num = UNINIT;
    locals.t.num = UNINIT;
    locals.k.num = UNINIT;
    locals.v.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPalter;
    locals.t = t;
    locals.k = k;
    locals.v = v;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->alter_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
        find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->alter_own_init == 0) {
        locals.type_own_ptr->alter_own_init = 1;
    }
    enter_proc(171);

  LINE(172);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.t.vec->data[4];
    T_1_2.num = locals.k.num;
    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) {

  LINE(173);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        T_2_1.num = locals.t.vec->data[6];
        T_2_3.num = locals.t.vec->data[2];
        CUR_PROC_VAR = T_2_3;
        locals.err = T_2_3.proc->proc(locals.k, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPadd(T_2_2, CLU_1, &T_2_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.t.vec->data[3]  = T_2_4.num;
        }
        }
        }/* end if */

  LINE(174);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.v.num;
    locals.t.vec->data[5]  = T_1_1.num;
    }

  LINE(175);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[1];
        locals.comper.num = T_1_1.num;
        }
        }

  LINE(176);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = locals.t.vec->data[0];
        T_1_2.num = locals.t.vec->data[3];
        locals.err = _vecOPfetch(T_1_1, T_1_2, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.xmb.num = T_1_3.num;
        }
        }

  LINE(177);
    {
        {locals.mb.num = locals.xmb.num;
        }
        }

  LINE(178);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = nil;
        T_1_2.num = (locals.mb.num == T_1_1.num)? true : false;
        T_1_3.num = T_1_2.num ^ 1;
        if (T_1_3.num != true) { break; }

  LINE(179);
        {
            {CLUREF T_2_1;
            T_2_1.num = locals.mb.num;
            locals.buck.num = T_2_1.num;
            }
            }

  LINE(180);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.buck.vec->data[0];
        CUR_PROC_VAR = locals.comper;
        locals.err = locals.comper.proc->proc(locals.k, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        if (T_2_2.num == true) {

  LINE(181);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.buck.vec->data[0];
            T_3_2.num = T_3_1.num;
            locals.t.vec->data[4]  = T_3_2.num;
            }

  LINE(182);
            {
            locals.buck.vec->data[2]  = locals.v.num;
            }

  LINE(183);
            {
            {signal (ERR_ok);}}
            }
            }/* end if */

  LINE(185);
        {
        CLUREF T_2_1;
        T_2_1.num = locals.buck.vec->data[1];
        locals.mb.num = T_2_1.num;
        }
        }
        end_while_1:;

  LINE(187);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.k.num;
    locals.t.vec->data[4]  = T_1_1.num;
    }

  LINE(188);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.t.vec->data[0];
    T_1_2.num = locals.t.vec->data[3];
    RecordAlloc(3, T_1_3);
    T_1_3.vec->data[0]  = locals.k.num;
    T_1_3.vec->data[2]  = locals.v.num;
    T_1_3.vec->data[1]  = locals.xmb.num;
    T_1_4.num = T_1_3.num;
    locals.err = _vecOPstore(T_1_1, T_1_2, T_1_4);
    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 alter ****/

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;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPalter_actual;
static Vlist0 vals_tableOPalter = {0, 0};
static siglist0 sigs_tableOPalter = {0, 0};
static Vlist10 locals_tableOPalter = {0, 10,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "comper", m1_ops},  {0, 2, "xmb", &_obj_ops},  {0, 2, "mb", &_obj_ops},  {0, 2, "buck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops},  {0, 2, "k", zero_ops, "key_ops"},  {0, 2, "v", zero_ops, "val_ops"}}
};
static Vlist0 popowns_tableOPalter = {0, 0};
Slist2 tformals_tableOPalter = {0, 2, "key", "val"};
Slist0 opformals_tableOPalter = {0, 0};
dbg_info_tableOPalter_actual dbg_info_tableOPalter_data = {0, 12, 
    "tableOPalter", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPalter, 3, 
    &vals_tableOPalter, &sigs_tableOPalter, &locals_tableOPalter, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPalter, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPalter = (struct dbg_info*)&dbg_info_tableOPalter_data;
extern struct dbg_info* dbg_info_tableOPlookup;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPlookup_TRACE
int tableOPlookup_TRACE;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE lookup ****/

errcode tableOPlookup(t, k, ret_1)
CLUREF t;
CLUREF k;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF comper;
        CLUREF mb;
        CLUREF buck;
        CLUREF t;
        CLUREF k;
        } locals;
    locals.comper.num = UNINIT;
    locals.mb.num = UNINIT;
    locals.buck.num = UNINIT;
    locals.t.num = UNINIT;
    locals.k.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPlookup;
    locals.t = t;
    locals.k = k;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->lookup_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
        find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->lookup_own_init == 0) {
        locals.type_own_ptr->lookup_own_init = 1;
    }
    enter_proc(195);

  LINE(196);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    T_1_1.num = locals.t.vec->data[4];
    T_1_2.num = locals.k.num;
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    if (T_1_3.num == true) {

  LINE(197);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.t.vec->data[5];
        T_2_2.num = (T_2_1.num == locals.type_own_ptr->unique.num)? true : false;
        if (T_2_2.num == true) {

  LINE(198);
            {
            {signal (ERR_not_found);}}
            }
            }/* end if */

  LINE(199);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.t.vec->data[5];
        T_2_2.num = T_2_1.num;
        ret_1->num = T_2_2.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(201);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.t.vec->data[6];
    T_1_3.num = locals.t.vec->data[2];
    CUR_PROC_VAR = T_1_3;
    locals.err = T_1_3.proc->proc(locals.k, T_1_1, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = intOPadd(T_1_2, CLU_1, &T_1_4);
    if (locals.err != ERR_ok) goto ex_0;
    locals.t.vec->data[3]  = T_1_4.num;
    }

  LINE(202);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[1];
        locals.comper.num = T_1_1.num;
        }
        }

  LINE(203);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = locals.t.vec->data[0];
        T_1_2.num = locals.t.vec->data[3];
        locals.err = _vecOPfetch(T_1_1, T_1_2, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.mb.num = T_1_3.num;
        }
        }

  LINE(204);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = nil;
        T_1_2.num = (locals.mb.num == T_1_1.num)? true : false;
        T_1_3.num = T_1_2.num ^ 1;
        if (T_1_3.num != true) { break; }

  LINE(205);
        {
            {CLUREF T_2_1;
            T_2_1.num = locals.mb.num;
            locals.buck.num = T_2_1.num;
            }
            }

  LINE(206);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.buck.vec->data[0];
        CUR_PROC_VAR = locals.comper;
        locals.err = locals.comper.proc->proc(locals.k, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        if (T_2_2.num == true) {

  LINE(207);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.buck.vec->data[0];
            T_3_2.num = T_3_1.num;
            locals.t.vec->data[4]  = T_3_2.num;
            }

  LINE(208);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.buck.vec->data[2];
            T_3_2.num = T_3_1.num;
            locals.t.vec->data[5]  = T_3_2.num;
            }

  LINE(209);
            {
            {
            CLUREF T_3_1;
            T_3_1.num = locals.buck.vec->data[2];
            ret_1->num = T_3_1.num;
            }
            {signal (ERR_ok);}}
            }
            }/* end if */

  LINE(211);
        {
        CLUREF T_2_1;
        T_2_1.num = locals.buck.vec->data[1];
        locals.mb.num = T_2_1.num;
        }
        }
        end_while_1:;

  LINE(213);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.k.num;
    locals.t.vec->data[4]  = T_1_1.num;
    }

  LINE(214);
    {
    locals.t.vec->data[5]  = locals.type_own_ptr->unique.num;
    }

  LINE(215);
    {
    {signal (ERR_not_found);}}
    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 lookup ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist8 *locals;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPlookup_actual;
static Vlist1 vals_tableOPlookup = {0, 1, { {0, 2, "", zero_ops, "val_ops"}}
};
static sig_desc0 sig_tableOPlookup_1 = {0, 3, "not_found", {0, 0
}};
static siglist1 sigs_tableOPlookup = {0, 1, (sig_desc*)&sig_tableOPlookup_1};
static Vlist8 locals_tableOPlookup = {0, 8,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "comper", m1_ops},  {0, 2, "mb", &_obj_ops},  {0, 2, "buck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops},  {0, 2, "k", zero_ops, "key_ops"}}
};
static Vlist0 popowns_tableOPlookup = {0, 0};
Slist2 tformals_tableOPlookup = {0, 2, "key", "val"};
Slist0 opformals_tableOPlookup = {0, 0};
dbg_info_tableOPlookup_actual dbg_info_tableOPlookup_data = {0, 12, 
    "tableOPlookup", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPlookup, 2, 
    &vals_tableOPlookup, &sigs_tableOPlookup, &locals_tableOPlookup, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPlookup, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPlookup = (struct dbg_info*)&dbg_info_tableOPlookup_data;
extern struct dbg_info* dbg_info_tableOPmlookup;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPmlookup_TRACE
int tableOPmlookup_TRACE;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE mlookup ****/

errcode tableOPmlookup(t, k, defv, ret_1)
CLUREF t;
CLUREF k;
CLUREF defv;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF comper;
        CLUREF mb;
        CLUREF buck;
        CLUREF t;
        CLUREF k;
        CLUREF defv;
        } locals;
    locals.comper.num = UNINIT;
    locals.mb.num = UNINIT;
    locals.buck.num = UNINIT;
    locals.t.num = UNINIT;
    locals.k.num = UNINIT;
    locals.defv.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPmlookup;
    locals.t = t;
    locals.k = k;
    locals.defv = defv;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->mlookup_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
        find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->mlookup_own_init == 0) {
        locals.type_own_ptr->mlookup_own_init = 1;
    }
    enter_proc(220);

  LINE(221);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    T_1_1.num = locals.t.vec->data[4];
    T_1_2.num = locals.k.num;
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    if (T_1_3.num == true) {

  LINE(222);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.t.vec->data[5];
        T_2_2.num = (T_2_1.num == locals.type_own_ptr->unique.num)? true : false;
        T_2_3.num = T_2_2.num ^ 1;
        if (T_2_3.num == true) {

  LINE(223);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.t.vec->data[5];
            T_3_2.num = T_3_1.num;
            locals.defv.num = T_3_2.num;
            }
            }
            }/* end if */

  LINE(224);
        {
        {
        ret_1->num = locals.defv.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(226);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.t.vec->data[6];
    T_1_3.num = locals.t.vec->data[2];
    CUR_PROC_VAR = T_1_3;
    locals.err = T_1_3.proc->proc(locals.k, T_1_1, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = intOPadd(T_1_2, CLU_1, &T_1_4);
    if (locals.err != ERR_ok) goto ex_0;
    locals.t.vec->data[3]  = T_1_4.num;
    }

  LINE(227);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[1];
        locals.comper.num = T_1_1.num;
        }
        }

  LINE(228);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = locals.t.vec->data[0];
        T_1_2.num = locals.t.vec->data[3];
        locals.err = _vecOPfetch(T_1_1, T_1_2, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.mb.num = T_1_3.num;
        }
        }

  LINE(229);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = nil;
        T_1_2.num = (locals.mb.num == T_1_1.num)? true : false;
        T_1_3.num = T_1_2.num ^ 1;
        if (T_1_3.num != true) { break; }

  LINE(230);
        {
            {CLUREF T_2_1;
            T_2_1.num = locals.mb.num;
            locals.buck.num = T_2_1.num;
            }
            }

  LINE(231);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.buck.vec->data[0];
        CUR_PROC_VAR = locals.comper;
        locals.err = locals.comper.proc->proc(locals.k, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        if (T_2_2.num == true) {

  LINE(232);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.buck.vec->data[0];
            T_3_2.num = T_3_1.num;
            locals.t.vec->data[4]  = T_3_2.num;
            }

  LINE(233);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.buck.vec->data[2];
            T_3_2.num = T_3_1.num;
            locals.t.vec->data[5]  = T_3_2.num;
            }

  LINE(234);
            {
            {
            CLUREF T_3_1;
            T_3_1.num = locals.buck.vec->data[2];
            ret_1->num = T_3_1.num;
            }
            {signal (ERR_ok);}}
            }
            }/* end if */

  LINE(236);
        {
        CLUREF T_2_1;
        T_2_1.num = locals.buck.vec->data[1];
        locals.mb.num = T_2_1.num;
        }
        }
        end_while_1:;

  LINE(238);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.k.num;
    locals.t.vec->data[4]  = T_1_1.num;
    }

  LINE(239);
    {
    locals.t.vec->data[5]  = locals.type_own_ptr->unique.num;
    }

  LINE(240);
    {
    {
    ret_1->num = locals.defv.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 mlookup ****/

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;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPmlookup_actual;
static Vlist1 vals_tableOPmlookup = {0, 1, { {0, 2, "", zero_ops, "val_ops"}}
};
static siglist0 sigs_tableOPmlookup = {0, 0};
static Vlist9 locals_tableOPmlookup = {0, 9,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "comper", m1_ops},  {0, 2, "mb", &_obj_ops},  {0, 2, "buck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops},  {0, 2, "k", zero_ops, "key_ops"},  {0, 2, "defv", zero_ops, "val_ops"}}
};
static Vlist0 popowns_tableOPmlookup = {0, 0};
Slist2 tformals_tableOPmlookup = {0, 2, "key", "val"};
Slist0 opformals_tableOPmlookup = {0, 0};
dbg_info_tableOPmlookup_actual dbg_info_tableOPmlookup_data = {0, 12, 
    "tableOPmlookup", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPmlookup, 3, 
    &vals_tableOPmlookup, &sigs_tableOPmlookup, &locals_tableOPmlookup, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPmlookup, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPmlookup = (struct dbg_info*)&dbg_info_tableOPmlookup_data;
extern struct dbg_info* dbg_info_tableOPget_pair;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPget_pair_TRACE
int tableOPget_pair_TRACE;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE get_pair ****/

errcode tableOPget_pair(t, k, ret_1, ret_2)
CLUREF t;
CLUREF k;
CLUREF *ret_1;
CLUREF *ret_2;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF comper;
        CLUREF mb;
        CLUREF buck;
        CLUREF t;
        CLUREF k;
        } locals;
    locals.comper.num = UNINIT;
    locals.mb.num = UNINIT;
    locals.buck.num = UNINIT;
    locals.t.num = UNINIT;
    locals.k.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPget_pair;
    locals.t = t;
    locals.k = k;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->get_pair_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
        find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->get_pair_own_init == 0) {
        locals.type_own_ptr->get_pair_own_init = 1;
    }
    enter_proc(246);

  LINE(247);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    T_1_1.num = locals.t.vec->data[4];
    T_1_2.num = locals.k.num;
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    if (T_1_3.num == true) {

  LINE(248);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.t.vec->data[5];
        T_2_2.num = (T_2_1.num == locals.type_own_ptr->unique.num)? true : false;
        if (T_2_2.num == true) {

  LINE(249);
            {
            {signal (ERR_not_found);}}
            }
            }/* end if */

  LINE(250);
        {
        {
        ret_1->num = locals.k.num;
        }
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.t.vec->data[5];
        T_2_2.num = T_2_1.num;
        ret_2->num = T_2_2.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(252);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.t.vec->data[6];
    T_1_3.num = locals.t.vec->data[2];
    CUR_PROC_VAR = T_1_3;
    locals.err = T_1_3.proc->proc(locals.k, T_1_1, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = intOPadd(T_1_2, CLU_1, &T_1_4);
    if (locals.err != ERR_ok) goto ex_0;
    locals.t.vec->data[3]  = T_1_4.num;
    }

  LINE(253);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[1];
        locals.comper.num = T_1_1.num;
        }
        }

  LINE(254);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = locals.t.vec->data[0];
        T_1_2.num = locals.t.vec->data[3];
        locals.err = _vecOPfetch(T_1_1, T_1_2, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.mb.num = T_1_3.num;
        }
        }

  LINE(255);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = nil;
        T_1_2.num = (locals.mb.num == T_1_1.num)? true : false;
        T_1_3.num = T_1_2.num ^ 1;
        if (T_1_3.num != true) { break; }

  LINE(256);
        {
            {CLUREF T_2_1;
            T_2_1.num = locals.mb.num;
            locals.buck.num = T_2_1.num;
            }
            }

  LINE(257);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.buck.vec->data[0];
        CUR_PROC_VAR = locals.comper;
        locals.err = locals.comper.proc->proc(locals.k, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        if (T_2_2.num == true) {

  LINE(258);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.buck.vec->data[0];
            T_3_2.num = T_3_1.num;
            locals.t.vec->data[4]  = T_3_2.num;
            }

  LINE(259);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.buck.vec->data[2];
            T_3_2.num = T_3_1.num;
            locals.t.vec->data[5]  = T_3_2.num;
            }

  LINE(260);
            {
            {
            CLUREF T_3_1;
            T_3_1.num = locals.buck.vec->data[0];
            ret_1->num = T_3_1.num;
            }
            {
            CLUREF T_3_2;
            T_3_2.num = locals.buck.vec->data[2];
            ret_2->num = T_3_2.num;
            }
            {signal (ERR_ok);}}
            }
            }/* end if */

  LINE(262);
        {
        CLUREF T_2_1;
        T_2_1.num = locals.buck.vec->data[1];
        locals.mb.num = T_2_1.num;
        }
        }
        end_while_1:;

  LINE(264);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.k.num;
    locals.t.vec->data[4]  = T_1_1.num;
    }

  LINE(265);
    {
    locals.t.vec->data[5]  = locals.type_own_ptr->unique.num;
    }

  LINE(266);
    {
    {signal (ERR_not_found);}}
    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 get_pair ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist2 *vals;
    siglist1 *sigs;
    Vlist8 *locals;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPget_pair_actual;
static Vlist2 vals_tableOPget_pair = {0, 2, { {0, 2, "", zero_ops, "key_ops"},  {0, 2, "", zero_ops, "val_ops"}}
};
static sig_desc0 sig_tableOPget_pair_1 = {0, 3, "not_found", {0, 0
}};
static siglist1 sigs_tableOPget_pair = {0, 1, (sig_desc*)&sig_tableOPget_pair_1};
static Vlist8 locals_tableOPget_pair = {0, 8,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "comper", m1_ops},  {0, 2, "mb", &_obj_ops},  {0, 2, "buck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops},  {0, 2, "k", zero_ops, "key_ops"}}
};
static Vlist0 popowns_tableOPget_pair = {0, 0};
Slist2 tformals_tableOPget_pair = {0, 2, "key", "val"};
Slist0 opformals_tableOPget_pair = {0, 0};
dbg_info_tableOPget_pair_actual dbg_info_tableOPget_pair_data = {0, 12, 
    "tableOPget_pair", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPget_pair, 2, 
    &vals_tableOPget_pair, &sigs_tableOPget_pair, &locals_tableOPget_pair, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPget_pair, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPget_pair = (struct dbg_info*)&dbg_info_tableOPget_pair_data;
extern struct dbg_info* dbg_info_tableOPexists;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPexists_TRACE
int tableOPexists_TRACE;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE exists ****/

errcode tableOPexists(t, k, ret_1)
CLUREF t;
CLUREF k;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF comper;
        CLUREF mb;
        CLUREF buck;
        CLUREF t;
        CLUREF k;
        } locals;
    locals.comper.num = UNINIT;
    locals.mb.num = UNINIT;
    locals.buck.num = UNINIT;
    locals.t.num = UNINIT;
    locals.k.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPexists;
    locals.t = t;
    locals.k = k;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->exists_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
        find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->exists_own_init == 0) {
        locals.type_own_ptr->exists_own_init = 1;
    }
    enter_proc(271);

  LINE(272);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    T_1_1.num = locals.t.vec->data[4];
    T_1_2.num = locals.k.num;
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    if (T_1_3.num == true) {

  LINE(273);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.t.vec->data[5];
        T_2_2.num = (T_2_1.num == locals.type_own_ptr->unique.num)? true : false;
        T_2_3.num = T_2_2.num ^ 1;
        ret_1->num = T_2_3.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(274);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.t.vec->data[6];
    T_1_3.num = locals.t.vec->data[2];
    CUR_PROC_VAR = T_1_3;
    locals.err = T_1_3.proc->proc(locals.k, T_1_1, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = intOPadd(T_1_2, CLU_1, &T_1_4);
    if (locals.err != ERR_ok) goto ex_0;
    locals.t.vec->data[3]  = T_1_4.num;
    }

  LINE(275);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[1];
        locals.comper.num = T_1_1.num;
        }
        }

  LINE(276);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = locals.t.vec->data[0];
        T_1_2.num = locals.t.vec->data[3];
        locals.err = _vecOPfetch(T_1_1, T_1_2, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.mb.num = T_1_3.num;
        }
        }

  LINE(277);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = nil;
        T_1_2.num = (locals.mb.num == T_1_1.num)? true : false;
        T_1_3.num = T_1_2.num ^ 1;
        if (T_1_3.num != true) { break; }

  LINE(278);
        {
            {CLUREF T_2_1;
            T_2_1.num = locals.mb.num;
            locals.buck.num = T_2_1.num;
            }
            }

  LINE(279);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.buck.vec->data[0];
        CUR_PROC_VAR = locals.comper;
        locals.err = locals.comper.proc->proc(locals.k, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        if (T_2_2.num == true) {

  LINE(280);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.buck.vec->data[0];
            T_3_2.num = T_3_1.num;
            locals.t.vec->data[4]  = T_3_2.num;
            }

  LINE(281);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.buck.vec->data[2];
            T_3_2.num = T_3_1.num;
            locals.t.vec->data[5]  = T_3_2.num;
            }

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

  LINE(284);
        {
        CLUREF T_2_1;
        T_2_1.num = locals.buck.vec->data[1];
        locals.mb.num = T_2_1.num;
        }
        }
        end_while_1:;

  LINE(286);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.k.num;
    locals.t.vec->data[4]  = T_1_1.num;
    }

  LINE(287);
    {
    locals.t.vec->data[5]  = locals.type_own_ptr->unique.num;
    }

  LINE(288);
    {
    {
    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 exists ****/

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;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPexists_actual;
static Vlist1 vals_tableOPexists = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_tableOPexists = {0, 0};
static Vlist8 locals_tableOPexists = {0, 8,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "comper", m1_ops},  {0, 2, "mb", &_obj_ops},  {0, 2, "buck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops},  {0, 2, "k", zero_ops, "key_ops"}}
};
static Vlist0 popowns_tableOPexists = {0, 0};
Slist2 tformals_tableOPexists = {0, 2, "key", "val"};
Slist0 opformals_tableOPexists = {0, 0};
dbg_info_tableOPexists_actual dbg_info_tableOPexists_data = {0, 12, 
    "tableOPexists", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPexists, 2, 
    &vals_tableOPexists, &sigs_tableOPexists, &locals_tableOPexists, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPexists, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPexists = (struct dbg_info*)&dbg_info_tableOPexists_data;
extern struct dbg_info* dbg_info_tableOPremove;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPremove_TRACE
int tableOPremove_TRACE;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE remove ****/

errcode tableOPremove(t, k, ret_1)
CLUREF t;
CLUREF k;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF comper;
        CLUREF i;
        CLUREF mb;
        CLUREF lbuck;
        CLUREF isprev;
        CLUREF buck;
        CLUREF t;
        CLUREF k;
        } locals;
    locals.comper.num = UNINIT;
    locals.i.num = UNINIT;
    locals.mb.num = UNINIT;
    locals.lbuck.num = UNINIT;
    locals.isprev.num = UNINIT;
    locals.buck.num = UNINIT;
    locals.t.num = UNINIT;
    locals.k.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPremove;
    locals.t = t;
    locals.k = k;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->remove_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
        find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->remove_own_init == 0) {
        locals.type_own_ptr->remove_own_init = 1;
    }
    enter_proc(294);

  LINE(295);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[1];
        locals.comper.num = T_1_1.num;
        }
        }

  LINE(296);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        T_1_1.num = locals.t.vec->data[6];
        T_1_3.num = locals.t.vec->data[2];
        CUR_PROC_VAR = T_1_3;
        locals.err = T_1_3.proc->proc(locals.k, T_1_1, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPadd(T_1_2, CLU_1, &T_1_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.i.num = T_1_4.num;
        }
        }

  LINE(297);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        T_1_1.num = locals.t.vec->data[0];
        locals.err = _vecOPfetch(T_1_1, locals.i, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.mb.num = T_1_2.num;
        }
        }

  LINE(298);
    locals.lbuck.num = UNINIT;

  LINE(299);
    {
        {locals.isprev.tf = false;
        }
        }

  LINE(300);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = nil;
        T_1_2.num = (locals.mb.num == T_1_1.num)? true : false;
        T_1_3.num = T_1_2.num ^ 1;
        if (T_1_3.num != true) { break; }

  LINE(301);
        {
            {CLUREF T_2_1;
            T_2_1.num = locals.mb.num;
            locals.buck.num = T_2_1.num;
            }
            }

  LINE(302);
        {
        CLUREF T_2_1;
        T_2_1.num = locals.buck.vec->data[1];
        locals.mb.num = T_2_1.num;
        }

  LINE(303);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.buck.vec->data[0];
        CUR_PROC_VAR = locals.comper;
        locals.err = locals.comper.proc->proc(locals.k, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        if (T_2_2.num == true) {

  LINE(304);
            {
            if (locals.isprev.num == true) {

  LINE(305);
                {
                locals.lbuck.vec->data[1]  = locals.mb.num;
                }
                }
            else {

  LINE(306);
                {
                CLUREF T_4_1;
                T_4_1.num = locals.t.vec->data[0];
                locals.err = _vecOPstore(T_4_1, locals.i, locals.mb);
                if (locals.err != ERR_ok) goto ex_0;
                }
                }}/* end if */

  LINE(308);
            {
            locals.t.vec->data[4]  = locals.type_own_ptr->unique.num;
            }

  LINE(309);
            {
            {
            CLUREF T_3_1;
            T_3_1.num = locals.buck.vec->data[2];
            ret_1->num = T_3_1.num;
            }
            {signal (ERR_ok);}}
            }
            }/* end if */

  LINE(311);
        {
        locals.lbuck.num = locals.buck.num;
        }

  LINE(312);
        {
        locals.isprev.tf = true;
        }
        }
        end_while_1:;

  LINE(314);
    {
    {signal (ERR_not_found);}}
    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 remove ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist11 *locals;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPremove_actual;
static Vlist1 vals_tableOPremove = {0, 1, { {0, 2, "", zero_ops, "val_ops"}}
};
static sig_desc0 sig_tableOPremove_1 = {0, 3, "not_found", {0, 0
}};
static siglist1 sigs_tableOPremove = {0, 1, (sig_desc*)&sig_tableOPremove_1};
static Vlist11 locals_tableOPremove = {0, 11,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "comper", m1_ops},  {0, 2, "i", &int_ops},  {0, 2, "mb", &_obj_ops},  {0, 2, "lbuck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "isprev", &bool_ops},  {0, 2, "buck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops},  {0, 2, "k", zero_ops, "key_ops"}}
};
static Vlist0 popowns_tableOPremove = {0, 0};
Slist2 tformals_tableOPremove = {0, 2, "key", "val"};
Slist0 opformals_tableOPremove = {0, 0};
dbg_info_tableOPremove_actual dbg_info_tableOPremove_data = {0, 12, 
    "tableOPremove", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPremove, 2, 
    &vals_tableOPremove, &sigs_tableOPremove, &locals_tableOPremove, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPremove, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPremove = (struct dbg_info*)&dbg_info_tableOPremove_data;
extern struct dbg_info* dbg_info_tableOPdelete;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPdelete_TRACE
int tableOPdelete_TRACE;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE delete ****/

errcode tableOPdelete(t, k)
CLUREF t;
CLUREF k;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF comper;
        CLUREF i;
        CLUREF mb;
        CLUREF lbuck;
        CLUREF isprev;
        CLUREF buck;
        CLUREF t;
        CLUREF k;
        } locals;
    locals.comper.num = UNINIT;
    locals.i.num = UNINIT;
    locals.mb.num = UNINIT;
    locals.lbuck.num = UNINIT;
    locals.isprev.num = UNINIT;
    locals.buck.num = UNINIT;
    locals.t.num = UNINIT;
    locals.k.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPdelete;
    locals.t = t;
    locals.k = k;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->delete_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
        find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->delete_own_init == 0) {
        locals.type_own_ptr->delete_own_init = 1;
    }
    enter_proc(319);

  LINE(320);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[1];
        locals.comper.num = T_1_1.num;
        }
        }

  LINE(321);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        T_1_1.num = locals.t.vec->data[6];
        T_1_3.num = locals.t.vec->data[2];
        CUR_PROC_VAR = T_1_3;
        locals.err = T_1_3.proc->proc(locals.k, T_1_1, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPadd(T_1_2, CLU_1, &T_1_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.i.num = T_1_4.num;
        }
        }

  LINE(322);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        T_1_1.num = locals.t.vec->data[0];
        locals.err = _vecOPfetch(T_1_1, locals.i, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.mb.num = T_1_2.num;
        }
        }

  LINE(323);
    locals.lbuck.num = UNINIT;

  LINE(324);
    {
        {locals.isprev.tf = false;
        }
        }

  LINE(325);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = nil;
        T_1_2.num = (locals.mb.num == T_1_1.num)? true : false;
        T_1_3.num = T_1_2.num ^ 1;
        if (T_1_3.num != true) { break; }

  LINE(326);
        {
            {CLUREF T_2_1;
            T_2_1.num = locals.mb.num;
            locals.buck.num = T_2_1.num;
            }
            }

  LINE(327);
        {
        CLUREF T_2_1;
        T_2_1.num = locals.buck.vec->data[1];
        locals.mb.num = T_2_1.num;
        }

  LINE(328);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.buck.vec->data[0];
        CUR_PROC_VAR = locals.comper;
        locals.err = locals.comper.proc->proc(locals.k, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        if (T_2_2.num == true) {

  LINE(329);
            {
            if (locals.isprev.num == true) {

  LINE(330);
                {
                locals.lbuck.vec->data[1]  = locals.mb.num;
                }
                }
            else {

  LINE(331);
                {
                CLUREF T_4_1;
                T_4_1.num = locals.t.vec->data[0];
                locals.err = _vecOPstore(T_4_1, locals.i, locals.mb);
                if (locals.err != ERR_ok) goto ex_0;
                }
                }}/* end if */

  LINE(333);
            {
            locals.t.vec->data[4]  = locals.type_own_ptr->unique.num;
            }

  LINE(334);
            {
            {signal (ERR_ok);}}
            }
            }/* end if */

  LINE(336);
        {
        locals.lbuck.num = locals.buck.num;
        }

  LINE(337);
        {
        locals.isprev.tf = true;
        }
        }
        end_while_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 delete ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist11 *locals;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPdelete_actual;
static Vlist0 vals_tableOPdelete = {0, 0};
static siglist0 sigs_tableOPdelete = {0, 0};
static Vlist11 locals_tableOPdelete = {0, 11,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "comper", m1_ops},  {0, 2, "i", &int_ops},  {0, 2, "mb", &_obj_ops},  {0, 2, "lbuck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "isprev", &bool_ops},  {0, 2, "buck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops},  {0, 2, "k", zero_ops, "key_ops"}}
};
static Vlist0 popowns_tableOPdelete = {0, 0};
Slist2 tformals_tableOPdelete = {0, 2, "key", "val"};
Slist0 opformals_tableOPdelete = {0, 0};
dbg_info_tableOPdelete_actual dbg_info_tableOPdelete_data = {0, 12, 
    "tableOPdelete", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPdelete, 2, 
    &vals_tableOPdelete, &sigs_tableOPdelete, &locals_tableOPdelete, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPdelete, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPdelete = (struct dbg_info*)&dbg_info_tableOPdelete_data;
extern struct dbg_info* dbg_info_tableOPrehash;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPrehash_TRACE
int tableOPrehash_TRACE;
extern errcode tableOPrehash_IB_1();
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE rehash ****/

errcode tableOPrehash(t, hasher)
CLUREF t;
CLUREF hasher;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF bucks;
        CLUREF size;
        CLUREF chain;
        CLUREF i;
        CLUREF nchain;
        CLUREF buck;
        CLUREF hash;
        CLUREF t;
        CLUREF hasher;
        } locals;
    locals.bucks.num = UNINIT;
    locals.size.num = UNINIT;
    locals.chain.num = UNINIT;
    locals.i.num = UNINIT;
    locals.nchain.num = UNINIT;
    locals.buck.num = UNINIT;
    locals.hash.num = UNINIT;
    locals.t.num = UNINIT;
    locals.hasher.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPrehash;
    locals.t = t;
    locals.hasher = hasher;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->rehash_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
        find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->rehash_own_init == 0) {
        locals.type_own_ptr->rehash_own_init = 1;
    }
    enter_proc(343);

  LINE(344);
    {
    locals.t.vec->data[2]  = locals.hasher.num;
    }

  LINE(345);
    {
    locals.t.vec->data[4]  = locals.type_own_ptr->unique.num;
    }

  LINE(346);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[0];
        locals.bucks.num = T_1_1.num;
        }
        }

  LINE(347);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[6];
        locals.size.num = T_1_1.num;
        }
        }

  LINE(348);
    {
        {CLUREF T_1_1;
        T_1_1.num = nil;
        locals.chain.num = T_1_1.num;
        }
        }

  LINE(349);
    {
        locals.err = intOPfrom_to(CLU_1, locals.size, tableOPrehash_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(361);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = nil;
        T_1_2.num = (locals.chain.num == T_1_1.num)? true : false;
        T_1_3.num = T_1_2.num ^ 1;
        if (T_1_3.num != true) { break; }

  LINE(362);
        {
            {CLUREF T_2_1;
            T_2_1.num = locals.chain.num;
            locals.buck.num = T_2_1.num;
            }
            }

  LINE(363);
        {
            {CLUREF T_2_1;
            T_2_1.num = locals.buck.vec->data[1];
            locals.nchain.num = T_2_1.num;
            }
            }

  LINE(364);
        {
            {CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            T_2_1.num = locals.buck.vec->data[0];
            CUR_PROC_VAR = locals.hasher;
            locals.err = locals.hasher.proc->proc(T_2_1, locals.size, &T_2_2);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = intOPadd(T_2_2, CLU_1, &T_2_3);
            if (locals.err != ERR_ok) goto ex_0;
            locals.hash.num = T_2_3.num;
            }
            }

  LINE(365);
        {
        CLUREF T_2_1;
        locals.err = _vecOPfetch(locals.bucks, locals.hash, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.buck.vec->data[1]  = T_2_1.num;
        }

  LINE(366);
        {
        locals.err = _vecOPstore(locals.bucks, locals.hash, locals.chain);
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(367);
        {
        locals.chain.num = locals.nchain.num;
        }
        }
        end_while_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 rehash ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist12 *locals;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPrehash_actual;
static Vlist0 vals_tableOPrehash = {0, 0};
static siglist0 sigs_tableOPrehash = {0, 0};
static Vlist12 locals_tableOPrehash = {0, 12,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "bucks", &_vec_of__obj_ops},  {0, 2, "size", &int_ops},  {0, 2, "chain", &_obj_ops},  {0, 2, "i", &int_ops},  {0, 2, "nchain", &_obj_ops},  {0, 2, "buck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "hash", &int_ops},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops},  {0, 2, "hasher", m1_ops}}
};
static Vlist0 popowns_tableOPrehash = {0, 0};
Slist2 tformals_tableOPrehash = {0, 2, "key", "val"};
Slist0 opformals_tableOPrehash = {0, 0};
dbg_info_tableOPrehash_actual dbg_info_tableOPrehash_data = {0, 12, 
    "tableOPrehash", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPrehash, 2, 
    &vals_tableOPrehash, &sigs_tableOPrehash, &locals_tableOPrehash, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPrehash, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPrehash = (struct dbg_info*)&dbg_info_tableOPrehash_data;

/**** BEGIN ITERATOR BODIES for rehash ****/

errcode tableOPrehash_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
table_OWN_DEFN *type_own_ptr;
    CLUREF bucks;
    CLUREF size;
    CLUREF chain;
    CLUREF i;
    CLUREF nchain;
    CLUREF buck;
    CLUREF hash;
    CLUREF t;
    CLUREF hasher;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(350);

  FB_LINE(350);
    {
        {CLUREF T_1_1;
        locals->err = _vecOPfetch(locals->bucks, locals->i, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->nchain.num = T_1_1.num;
        }
        }

  FB_LINE(351);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = nil;
    T_1_2.num = (locals->nchain.num == T_1_1.num)? true : false;
    if (T_1_2.num == true) {

  FB_LINE(352);
        {signal(ERR_ok);}
        }
        }/* end if */

  FB_LINE(353);
    {
    CLUREF T_1_1;
    T_1_1.num = nil;
    locals->err = _vecOPstore(locals->bucks, locals->i, T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    }

  FB_LINE(354);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals->nchain.num;
        locals->buck.num = T_1_1.num;
        }
        }

  FB_LINE(355);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        T_1_1.num = locals->buck.vec->data[1];
        T_1_2.num = nil;
        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) { break; }

  FB_LINE(356);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals->buck.vec->data[1];
        T_2_2.num = T_2_1.num;
        locals->buck.num = T_2_2.num;
        }
        }
        end_while_2:;

  FB_LINE(358);
    {
    locals->buck.vec->data[1]  = locals->chain.num;
    }

  FB_LINE(359);
    {
    locals->chain.num = locals->nchain.num;
    }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end tableOPrehash_IB_1 */

/**** END ITERATOR BODIES for rehash ****/

extern struct dbg_info* dbg_info_tableOPelements;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPelements_TRACE
int tableOPelements_TRACE;
extern errcode tableOPelements_IB_1();
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN ITERATOR elements ****/

errcode tableOPelements(t, proc, user_locals, iecode)
CLUREF t;
errcode (*proc)();
char **user_locals;
errcode *iecode;
    {
    errcode ecode;
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        char **user_locals;
        errcode (*proc)();
        errcode err;
        errcode ecode2;
        bool body_ctrl_req;
        table_OWN_DEFN *type_own_ptr;
        CLUREF bucks;
        CLUREF i;
        CLUREF mb;
        CLUREF buck;
        CLUREF t;
        } locals;
    locals.bucks.num = UNINIT;
    locals.i.num = UNINIT;
    locals.mb.num = UNINIT;
    locals.buck.num = UNINIT;
    locals.t.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPelements;
    locals.t = t;
    locals.proc = proc;
    locals.user_locals = user_locals;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
    locals.user_locals = user_locals;
    locals.proc = proc;
        if (locals.type_own_ptr->elements_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
        find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->elements_own_init == 0) {
        locals.type_own_ptr->elements_own_init = 1;
    }
    enter_proc(373);

  LINE(374);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[0];
        locals.bucks.num = T_1_1.num;
        }
        }

  LINE(375);
    {
        CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[6];
        locals.body_ctrl_req = false;
        locals.err = intOPfrom_to(CLU_1, T_1_1, tableOPelements_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {signal(ERR_iterbodyreturn);}
        if (locals.err == ERR_iterbodysignal) {
            *iecode = locals.ecode2; signal(ERR_iterbodysignal);}
        if (locals.err == ERR_iterbodyexit) {
            *iecode = locals.ecode2; signal(ERR_iterbodyexit);}
        if (locals.body_ctrl_req == true) {
            locals.body_ctrl_req = false;
            if (locals.err == ERR_iteriterbodyreturn) {signal(ERR_ok);}
            if (locals.err == ERR_iteriterbodysignal) {signal(locals.ecode2);}
            if (locals.err == ERR_break) locals.err = ERR_ok;
            if (locals.err == ERR_iteriterbodyexit) locals.err = locals.ecode2;
            }
        else {
            if (locals.err == ERR_iteriterbodyreturn) {signal(ERR_iteriterbodyreturn);}
            if (locals.err == ERR_break) {signal(ERR_break);}
            if (locals.err == ERR_iteriterbodysignal) {
                  *iecode = locals.ecode2; signal(ERR_iteriterbodysignal);}
            if (locals.err == ERR_iteriterbodyexit) {
                  *iecode = locals.ecode2; signal(ERR_iteriterbodyexit);}}
        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 ITERATOR elements ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist2 *vals;
    siglist0 *sigs;
    Vlist11 *locals;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPelements_actual;
static Vlist2 vals_tableOPelements = {0, 2, { {0, 2, "", zero_ops, "key_ops"},  {0, 2, "", zero_ops, "val_ops"}}
};
static siglist0 sigs_tableOPelements = {0, 0};
static Vlist11 locals_tableOPelements = {0, 11,{ {0, 2, "user_locals", &int_ops},  {0, 2, "proc", &int_ops},  {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "body_ctrl_req", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "bucks", &_vec_of__obj_ops},  {0, 2, "i", &int_ops},  {0, 2, "mb", &_obj_ops},  {0, 2, "buck", zero_ops, "record_key_next_val_1_ops"},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops}}
};
static Vlist0 popowns_tableOPelements = {0, 0};
Slist2 tformals_tableOPelements = {0, 2, "key", "val"};
Slist0 opformals_tableOPelements = {0, 0};
dbg_info_tableOPelements_actual dbg_info_tableOPelements_data = {0, 12, 
    "tableOPelements", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 1, 2, (int)tableOPelements, 1, 
    &vals_tableOPelements, &sigs_tableOPelements, &locals_tableOPelements, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPelements, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPelements = (struct dbg_info*)&dbg_info_tableOPelements_data;

/**** BEGIN ITERATOR BODIES for elements ****/

errcode tableOPelements_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    char **user_locals;
    errcode (*proc)();
    errcode err;
    errcode ecode2;
    bool body_ctrl_req;
table_OWN_DEFN *type_own_ptr;
    CLUREF bucks;
    CLUREF i;
    CLUREF mb;
    CLUREF buck;
    CLUREF t;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(376);

  FB_LINE(376);
    {
        {CLUREF T_1_1;
        locals->err = _vecOPfetch(locals->bucks, locals->i, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->mb.num = T_1_1.num;
        }
        }

  FB_LINE(377);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = nil;
        T_1_2.num = (locals->mb.num == T_1_1.num)? true : false;
        T_1_3.num = T_1_2.num ^ 1;
        if (T_1_3.num != true) { break; }

  FB_LINE(378);
        {
            {CLUREF T_2_1;
            T_2_1.num = locals->mb.num;
            locals->buck.num = T_2_1.num;
            }
            }

  FB_LINE(379);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals->buck.vec->data[0];
        T_2_2.num = locals->buck.vec->data[2];
        locals->err = locals->proc(T_2_1, T_2_2, locals->user_locals, iecode);
        if ((locals->body_ctrl_req == true) && (locals->err == ERR_iteriterbodyexit)) {
            locals->err = *iecode;
            goto ex_0;}
        if (locals->err != ERR_ok) {
        signal(locals->err);
        }
        }

  FB_LINE(380);
        {
        CLUREF T_2_1;
        T_2_1.num = locals->buck.vec->data[1];
        locals->mb.num = T_2_1.num;
        }
        }
        end_while_1:;
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            locals->body_ctrl_req = true;
            {signal(ERR_iteriterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end tableOPelements_IB_1 */

/**** END ITERATOR BODIES for elements ****/

extern struct dbg_info* dbg_info_tableOPcount;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPcount_TRACE
int tableOPcount_TRACE;
extern errcode tableOPcount_IB_1();
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE count ****/

errcode tableOPcount(t, ret_1)
CLUREF t;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF cnt;
        CLUREF bucks;
        CLUREF i;
        CLUREF mb;
        CLUREF t;
        } locals;
    locals.cnt.num = UNINIT;
    locals.bucks.num = UNINIT;
    locals.i.num = UNINIT;
    locals.mb.num = UNINIT;
    locals.t.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPcount;
    locals.t = t;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->count_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
        find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->count_own_init == 0) {
        locals.type_own_ptr->count_own_init = 1;
    }
    enter_proc(387);

  LINE(388);
    {
        {locals.cnt.num = 0;
        }
        }

  LINE(389);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[0];
        locals.bucks.num = T_1_1.num;
        }
        }

  LINE(390);
    {
        CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[6];
        locals.err = intOPfrom_to(CLU_1, T_1_1, tableOPcount_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(397);
    {
    {
    ret_1->num = locals.cnt.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 count ****/

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;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPcount_actual;
static Vlist1 vals_tableOPcount = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_tableOPcount = {0, 0};
static Vlist8 locals_tableOPcount = {0, 8,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "cnt", &int_ops},  {0, 2, "bucks", &_vec_of__obj_ops},  {0, 2, "i", &int_ops},  {0, 2, "mb", &_obj_ops},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops}}
};
static Vlist0 popowns_tableOPcount = {0, 0};
Slist2 tformals_tableOPcount = {0, 2, "key", "val"};
Slist0 opformals_tableOPcount = {0, 0};
dbg_info_tableOPcount_actual dbg_info_tableOPcount_data = {0, 12, 
    "tableOPcount", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPcount, 1, 
    &vals_tableOPcount, &sigs_tableOPcount, &locals_tableOPcount, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPcount, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPcount = (struct dbg_info*)&dbg_info_tableOPcount_data;

/**** BEGIN ITERATOR BODIES for count ****/

errcode tableOPcount_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
table_OWN_DEFN *type_own_ptr;
    CLUREF cnt;
    CLUREF bucks;
    CLUREF i;
    CLUREF mb;
    CLUREF t;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(391);

  FB_LINE(391);
    {
        {CLUREF T_1_1;
        locals->err = _vecOPfetch(locals->bucks, locals->i, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->mb.num = T_1_1.num;
        }
        }

  FB_LINE(392);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = nil;
        T_1_2.num = (locals->mb.num == T_1_1.num)? true : false;
        T_1_3.num = T_1_2.num ^ 1;
        if (T_1_3.num != true) { break; }

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

  FB_LINE(394);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals->mb.num;
        T_2_2.num = T_2_1.vec->data[1];
        locals->mb.num = T_2_2.num;
        }
        }
        end_while_1:;
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end tableOPcount_IB_1 */

/**** END ITERATOR BODIES for count ****/

extern struct dbg_info* dbg_info_tableOPempty;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPempty_TRACE
int tableOPempty_TRACE;
extern errcode tableOPempty_IB_1();
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE empty ****/

errcode tableOPempty(t, ret_1)
CLUREF t;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF bucks;
        CLUREF i;
        CLUREF t;
        } locals;
    locals.bucks.num = UNINIT;
    locals.i.num = UNINIT;
    locals.t.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPempty;
    locals.t = t;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->empty_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->empty_own_init == 0) {
        locals.type_own_ptr->empty_own_init = 1;
    }
    enter_proc(402);

  LINE(403);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[0];
        locals.bucks.num = T_1_1.num;
        }
        }

  LINE(404);
    {
        CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[6];
        locals.err = intOPfrom_to(CLU_1, T_1_1, tableOPempty_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(408);
    {
    {
    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 empty ****/

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;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPempty_actual;
static Vlist1 vals_tableOPempty = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_tableOPempty = {0, 0};
static Vlist6 locals_tableOPempty = {0, 6,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "bucks", &_vec_of__obj_ops},  {0, 2, "i", &int_ops},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops}}
};
static Vlist0 popowns_tableOPempty = {0, 0};
Slist2 tformals_tableOPempty = {0, 2, "key", "val"};
Slist0 opformals_tableOPempty = {0, 0};
dbg_info_tableOPempty_actual dbg_info_tableOPempty_data = {0, 12, 
    "tableOPempty", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPempty, 1, 
    &vals_tableOPempty, &sigs_tableOPempty, &locals_tableOPempty, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPempty, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPempty = (struct dbg_info*)&dbg_info_tableOPempty_data;

/**** BEGIN ITERATOR BODIES for empty ****/

errcode tableOPempty_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
table_OWN_DEFN *type_own_ptr;
    CLUREF bucks;
    CLUREF i;
    CLUREF t;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(405);

  FB_LINE(405);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    locals->err = _vecOPfetch(locals->bucks, locals->i, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    T_1_2.num = nil;
    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) {

  FB_LINE(406);
        {
        {
        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 tableOPempty_IB_1 */

/**** END ITERATOR BODIES for empty ****/

extern struct dbg_info* dbg_info_tableOPsizes;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPsizes_TRACE
int tableOPsizes_TRACE;
extern errcode tableOPsizes_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;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

/**** BEGIN PROCEDURE sizes ****/

errcode tableOPsizes(t, ret_1)
CLUREF t;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF z;
        CLUREF bucks;
        CLUREF i;
        CLUREF cnt;
        CLUREF mb;
        CLUREF t;
        } locals;
    locals.z.num = UNINIT;
    locals.bucks.num = UNINIT;
    locals.i.num = UNINIT;
    locals.cnt.num = UNINIT;
    locals.mb.num = UNINIT;
    locals.t.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPsizes;
    locals.t = t;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->sizes_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, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        add_selector_info("key", 0, locals.type_own_ptr->key_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, locals.type_own_ptr->val_ops); 
        find_selector_ops("record", 3, &(locals.type_own_ptr->record_key_next_val_1_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->sizes_own_init == 0) {
        locals.type_own_ptr->sizes_own_init = 1;
    }
    enter_proc(414);

  LINE(416);
    {
        {CLUREF T_1_1;
        locals.err = arrayOPcreate(CLU_0, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.z.num = T_1_1.num;
        }
        }

  LINE(417);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[0];
        locals.bucks.num = T_1_1.num;
        }
        }

  LINE(418);
    {
        CLUREF T_1_1;
        T_1_1.num = locals.t.vec->data[6];
        locals.err = intOPfrom_to(CLU_1, T_1_1, tableOPsizes_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(433);
    {
    {
    ret_1->num = locals.z.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 sizes ****/

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;
    Vlist9 *locals;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPsizes_actual;
static Vlist1 vals_tableOPsizes = {0, 1, { {0, 2, "", &array_of_int_ops}}
};
static siglist0 sigs_tableOPsizes = {0, 0};
static Vlist9 locals_tableOPsizes = {0, 9,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "z", &array_of_int_ops},  {0, 2, "bucks", &_vec_of__obj_ops},  {0, 2, "i", &int_ops},  {0, 2, "cnt", &int_ops},  {0, 2, "mb", &_obj_ops},  {0, 2, "t", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops}}
};
static Vlist0 popowns_tableOPsizes = {0, 0};
Slist2 tformals_tableOPsizes = {0, 2, "key", "val"};
Slist0 opformals_tableOPsizes = {0, 0};
dbg_info_tableOPsizes_actual dbg_info_tableOPsizes_data = {0, 12, 
    "tableOPsizes", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPsizes, 1, 
    &vals_tableOPsizes, &sigs_tableOPsizes, &locals_tableOPsizes, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPsizes, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPsizes = (struct dbg_info*)&dbg_info_tableOPsizes_data;

/**** BEGIN ITERATOR BODIES for sizes ****/

errcode tableOPsizes_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
table_OWN_DEFN *type_own_ptr;
    CLUREF z;
    CLUREF bucks;
    CLUREF i;
    CLUREF cnt;
    CLUREF mb;
    CLUREF t;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(419);

  FB_LINE(419);
    {
        {locals->cnt.num = 0;
        }
        }

  FB_LINE(420);
    {
        {CLUREF T_1_1;
        locals->err = _vecOPfetch(locals->bucks, locals->i, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->mb.num = T_1_1.num;
        }
        }

  FB_LINE(421);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = nil;
        T_1_2.num = (locals->mb.num == T_1_1.num)? true : false;
        T_1_3.num = T_1_2.num ^ 1;
        if (T_1_3.num != true) { break; }

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

  FB_LINE(423);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals->mb.num;
        T_2_2.num = T_2_1.vec->data[1];
        locals->mb.num = T_2_2.num;
        }
        }
        end_while_1:;

  FB_LINE(425);
    {
    CLUREF T_2_1;
    CLUREF T_2_2;
    locals->err = arrayOPfetch(locals->z, locals->cnt, &T_2_1);
    if (locals->err != ERR_ok) goto ex_1;
    locals->err = intOPadd(T_2_1, CLU_1, &T_2_2);
    if (locals->err != ERR_ok) goto ex_1;
    locals->err = arrayOPstore(locals->z, locals->cnt, T_2_2);
    if (locals->err != ERR_ok) goto ex_1;
    }
        goto end_1;
        ex_1:
            if ((locals->err == ERR_bounds)) {

  FB_LINE(427);
                for (;;) {
                    CLUREF T_2_1;
                    CLUREF T_2_2;
                    T_2_1.num = locals->z.array->ext_size;
                    T_2_2.num = (T_2_1.num < locals->cnt.num)? true : false;
                    if (T_2_2.num != true) { break; }

  FB_LINE(428);
                    {
                    locals->err = arrayOPaddh(locals->z, CLU_0);
                    if (locals->err != ERR_ok) goto ex_0;
                    }
                    }
                    end_while_2:;

  FB_LINE(430);
                {
                locals->err = arrayOPaddh(locals->z, CLU_1);
                if (locals->err != ERR_ok) goto ex_0;
                }
            }
            else {
                goto ex_0;
            }
        end_1:;
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end tableOPsizes_IB_1 */

/**** END ITERATOR BODIES for sizes ****/

extern struct dbg_info* dbg_info_tableOPdebug_print;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG tableOPdebug_print_TRACE
int tableOPdebug_print_TRACE;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
struct OPS  *record_buckets_comper_hasher_lhash_lkey_lval_size_ops;

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

errcode tableOPdebug_print(_rep, ps)
CLUREF _rep;
CLUREF ps;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        table_OWN_DEFN *type_own_ptr;
        CLUREF _rep;
        CLUREF ps;
        } locals;
    locals._rep.num = UNINIT;
    locals.ps.num = UNINIT;
    locals.DBG_INFO = dbg_info_tableOPdebug_print;
    locals._rep = _rep;
    locals.ps = ps;
    locals.type_own_ptr = (table_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->debug_print_own_init == 0) {
        add_parm_info_type(0, _obj_ops, _vec_of_t_reqs);
        find_type_instance(_vec_ops, 1, &_vec_ownreqs, &(_vec_of__obj_ops));
        add_selector_info("buckets", 0, _vec_of__obj_ops); 
        add_selector_info("comper", 1, proctype_ops); 
        add_selector_info("hasher", 2, proctype_ops); 
        add_selector_info("lhash", 3, int_ops); 
        add_selector_info("lkey", 4, _obj_ops); 
        add_selector_info("lval", 5, _obj_ops); 
        add_selector_info("size", 6, int_ops); 
        find_selector_ops("record", 7, &(record_buckets_comper_hasher_lhash_lkey_lval_size_ops));
        }
            if (locals.type_own_ptr->table_own_init == 0) {
            generic_CLU_proc.type_owns = (OWNPTR)locals.type_own_ptr;
            generic_CLU_proc.op_owns = 0;
            generic_CLU_proc.proc = table_own_init_proc;
            locals.err = generic_CLU_proc.proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        if (locals.type_own_ptr->debug_print_own_init == 0) {
        locals.type_own_ptr->debug_print_own_init = 1;
    }
    enter_proc(1);

  LINE(2);
    {
    generic_CLU_proc.type_owns = 0;
    generic_CLU_proc.op_owns = record_buckets_comper_hasher_lhash_lkey_lval_size_ops->entry[7].fcn->op_owns;
    generic_CLU_proc.proc = recordOPdebug_print;
    CUR_PROC_VAR.proc = &generic_CLU_proc;
    locals.err = recordOPdebug_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;
    Vlist5 *locals;
    Vlist0 *owns;
    Vlist23 *ptowns;
    Vlist0 *popowns;
    Slist2 *type_formals;
    Slist0 *op_formals;
    } dbg_info_tableOPdebug_print_actual;
static Vlist0 vals_tableOPdebug_print = {0, 0};
static siglist0 sigs_tableOPdebug_print = {0, 0};
static Vlist5 locals_tableOPdebug_print = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "_rep", &record_buckets_comper_hasher_lhash_lkey_lval_size_ops},  {0, 2, "ps", &pstream_ops}}
};
static Vlist0 popowns_tableOPdebug_print = {0, 0};
Slist2 tformals_tableOPdebug_print = {0, 2, "key", "val"};
Slist0 opformals_tableOPdebug_print = {0, 0};
dbg_info_tableOPdebug_print_actual dbg_info_tableOPdebug_print_data = {0, 12, 
    "tableOPdebug_print", "/common/pub/dcurtis-temp/pclu/lib/clu/table.clu", 0, 2, (int)tableOPdebug_print, 2, 
    &vals_tableOPdebug_print, &sigs_tableOPdebug_print, &locals_tableOPdebug_print, &NO_VALS, &ptowns_table, &NO_VALS, &tformals_tableOPdebug_print, &NO_PARMS};
    struct dbg_info *dbg_info_tableOPdebug_print = (struct dbg_info*)&dbg_info_tableOPdebug_print_data;
typedef struct{
    int count;
    OWNPTR type_owns;
    OWNPTR op_owns;
    struct OP_ENTRY entry[19];
} table_OPS;

CLU_proc table_oe_alter = {{0,0,0,0}, tableOPalter, 0};
CLU_proc table_oe_bind = {{0,0,0,0}, tableOPbind, 0};
CLU_proc table_oe_cond_flush = {{0,0,0,0}, tableOPcond_flush, 0};
CLU_proc table_oe_count = {{0,0,0,0}, tableOPcount, 0};
CLU_proc table_oe_create = {{0,0,0,0}, tableOPcreate, 0};
CLU_proc table_oe_delete = {{0,0,0,0}, tableOPdelete, 0};
CLU_proc table_oe_elements = {{0,0,0,0}, tableOPelements, 0};
CLU_proc table_oe_empty = {{0,0,0,0}, tableOPempty, 0};
CLU_proc table_oe_exists = {{0,0,0,0}, tableOPexists, 0};
CLU_proc table_oe_flush = {{0,0,0,0}, tableOPflush, 0};
CLU_proc table_oe_get_pair = {{0,0,0,0}, tableOPget_pair, 0};
CLU_proc table_oe_lookup = {{0,0,0,0}, tableOPlookup, 0};
CLU_proc table_oe_mbind = {{0,0,0,0}, tableOPmbind, 0};
CLU_proc table_oe_mlookup = {{0,0,0,0}, tableOPmlookup, 0};
CLU_proc table_oe_pcond_flush = {{0,0,0,0}, tableOPpcond_flush, 0};
CLU_proc table_oe_rehash = {{0,0,0,0}, tableOPrehash, 0};
CLU_proc table_oe_remove = {{0,0,0,0}, tableOPremove, 0};
CLU_proc table_oe_sizes = {{0,0,0,0}, tableOPsizes, 0};
CLU_proc table_oe_debug_print = {{0,0,0,0}, tableOPdebug_print, 0};

table_OPS table_ops_actual = {19, (OWNPTR)&table_own_init, (OWNPTR)&table_own_init, {
    {&table_oe_alter, "alter"},
    {&table_oe_bind, "bind"},
    {&table_oe_cond_flush, "cond_flush"},
    {&table_oe_count, "count"},
    {&table_oe_create, "create"},
    {&table_oe_delete, "delete"},
    {&table_oe_elements, "elements"},
    {&table_oe_empty, "empty"},
    {&table_oe_exists, "exists"},
    {&table_oe_flush, "flush"},
    {&table_oe_get_pair, "get_pair"},
    {&table_oe_lookup, "lookup"},
    {&table_oe_mbind, "mbind"},
    {&table_oe_mlookup, "mlookup"},
    {&table_oe_pcond_flush, "pcond_flush"},
    {&table_oe_rehash, "rehash"},
    {&table_oe_remove, "remove"},
    {&table_oe_sizes, "sizes"},
    {&table_oe_debug_print, "debug_print"}}};

struct OPS *table_ops = (struct OPS *)&table_ops_actual;

/**** END CLUSTER table ****/