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

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


extern struct dbg_info* dbg_info_gc_read;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gc_read_TRACE
int gc_read_TRACE;
extern struct OPS *int_ops;
static Vlist0 owns_gc_read = {0, 0};

typedef struct {
int count;
} gc_read_of_t_REQS;

gc_read_of_t_REQS gc_read_of_t_reqs_actual = {0};

struct REQS * gc_read_of_t_reqs = (struct REQS *)&gc_read_of_t_reqs_actual;


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

extern errcode gcbOPinit();
extern errcode gcoOPinit();
extern errcode _chanOPopen();
extern errcode _bytevecOPcreate();
extern errcode _cvt();
extern errcode _chanOPgetb();
extern errcode boolOPnot();
extern errcode charOPequal();
extern errcode _bytevecOPfetch();
extern errcode intOPequal();
extern errcode _wordvecOPfetch();
extern errcode gcrOPpass1();
extern errcode _chanOPclose();
extern errcode gcrOPpass2();
extern errcode gcoOPget_obj();
extern errcode gcoOPreset();
extern OWN_req gcb_ownreqs;
extern struct OPS *gcb_ops;
CLUREF STR_read;
CLUREF STR_bad_040file_040format;

typedef struct {
    int gc_read_own_init;
    gc_read_of_t_OPS *t_ops;
    } gc_read_OWN_DEFN;
OWN_req gc_read_ownreqs = {sizeof(gc_read_OWN_DEFN), 1};


/**** BEGIN PROCEDURE gc_read ****/

errcode gc_read(fn, ret_1)
CLUREF fn;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        gc_read_OWN_DEFN *op_own_ptr;
        CLUREF ch;
        CLUREF why;
        CLUREF bv8;
        CLUREF wv2;
        CLUREF result;
        CLUREF fn;
        } locals;
    locals.ch.num = UNINIT;
    locals.why.num = UNINIT;
    locals.bv8.num = UNINIT;
    locals.wv2.num = UNINIT;
    locals.result.num = UNINIT;
    locals.fn.num = UNINIT;
    locals.DBG_INFO = dbg_info_gc_read;
    locals.fn = fn;
    locals.op_own_ptr = (gc_read_OWN_DEFN*) CUR_PROC_VAR.proc->op_owns;
        if (locals.op_own_ptr->gc_read_own_init == 0) {
        stringOPcons("read", CLU_1, CLU_4, &STR_read);
        stringOPcons("bad file format", CLU_1, CLU_15, &STR_bad_040file_040format);
        }
        if (locals.op_own_ptr->gc_read_own_init == 0) {
        locals.op_own_ptr->gc_read_own_init = 1;
    }
    enter_proc(4);

  LINE(11);
    locals.ch.num = UNINIT;

  LINE(12);
    {

  LINE(13);
        {
        locals.err = gcbOPinit();
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(14);
        {
        locals.err = gcoOPinit();
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(15);
        {
        CLUREF T_4_1;
        locals.err = _chanOPopen(locals.fn, STR_read, CLU_0, &T_4_1);
        if (locals.err != ERR_ok) goto ex_2;
        locals.ch.num = T_4_1.num;
        }
            goto end_2;
            ex_2:
                if ((locals.err == ERR_not_possible)) {
                CLUREF why;
                locals.why.num = elist[0].num;

  LINE(17);
                    {
                    elist[0] = locals.why;
                    {signal (ERR_not_possible);}}
                }
                else {
                    goto ex_1;
                }
            end_2:;

  LINE(19);
        {
            {CLUREF T_3_1;
            locals.err = _bytevecOPcreate(CLU_8, &T_3_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.bv8.num = T_3_1.num;
            }
            }

  LINE(20);
        {
            {CLUREF T_3_1;
            T_3_1.num = locals.bv8.num;
            locals.wv2.num = T_3_1.num;
            }
            }

  LINE(24);
        {
        CLUREF T_3_1;
        locals.err = _chanOPgetb(locals.ch, locals.bv8, &T_3_1);
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(26);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        CLUREF T_3_4;
        CLUREF T_3_5;
        CLUREF T_3_6;
        CLUREF T_3_7;
        CLUREF T_3_8;
        CLUREF T_3_9;
        CLUREF T_3_10;
        CLUREF T_3_11;
        CLUREF T_3_12;
        CLUREF T_3_13;
        CLUREF T_3_14;
        CLUREF T_3_15;
        CLUREF T_3_16;
        CLUREF T_3_17;
        CLUREF T_3_18;
        CLUREF T_3_19;
        locals.err = _bytevecOPfetch(locals.bv8, CLU_1, &T_3_4);
        if (locals.err != ERR_ok) goto ex_1;
        T_3_5.ch = 'D';
        T_3_6.num = (T_3_4.ch == T_3_5.ch)? true : false;
        T_3_7.num = T_3_6.num ^ 1;
        T_3_3.num = T_3_7.num;
        if (!T_3_7.num) {
            locals.err = _bytevecOPfetch(locals.bv8, CLU_2, &T_3_8);
            if (locals.err != ERR_ok) goto ex_1;
            T_3_9.ch = 'W';
            T_3_10.num = (T_3_8.ch == T_3_9.ch)? true : false;
            T_3_11.num = T_3_10.num ^ 1;
            T_3_3.num = T_3_11.num;
        }
        T_3_2.num = T_3_3.num;
        if (!T_3_3.num) {
            locals.err = _bytevecOPfetch(locals.bv8, CLU_3, &T_3_12);
            if (locals.err != ERR_ok) goto ex_1;
            T_3_13.ch = 'C';
            T_3_14.num = (T_3_12.ch == T_3_13.ch)? true : false;
            T_3_15.num = T_3_14.num ^ 1;
            T_3_2.num = T_3_15.num;
        }
        T_3_1.num = T_3_2.num;
        if (!T_3_2.num) {
            locals.err = _bytevecOPfetch(locals.bv8, CLU_4, &T_3_16);
            if (locals.err != ERR_ok) goto ex_1;
            T_3_17.ch = '1';
            T_3_18.num = (T_3_16.ch == T_3_17.ch)? true : false;
            T_3_19.num = T_3_18.num ^ 1;
            T_3_1.num = T_3_19.num;
        }
        if (T_3_1.num == true) {

  LINE(31);
            {
            elist[0] = STR_bad_040file_040format;
            {signal (ERR_not_possible);}}
            }
            }/* end if */

  LINE(36);
        {
        CLUREF T_3_1;
        locals.err = _chanOPgetb(locals.ch, locals.bv8, &T_3_1);
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(37);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        locals.err = _wordvecOPfetch(locals.wv2, CLU_1, &T_3_1);
        if (locals.err != ERR_ok) goto ex_1;
        T_3_2.num = (T_3_1.num == 32)? true : false;
        if (T_3_2.num == true) {

  LINE(40);
            {
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            locals.err = _wordvecOPfetch(locals.wv2, CLU_2, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            T_4_2.num = T_4_1.num;
            ret_1->num = T_4_2.num;
            }
            {signal (ERR_ok);}}
            }
            }/* end if */

  LINE(45);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        locals.err = _wordvecOPfetch(locals.wv2, CLU_1, &T_3_1);
        if (locals.err != ERR_ok) goto ex_1;
        T_3_2.num = (T_3_1.num == 33)? true : false;
        T_3_3.num = T_3_2.num ^ 1;
        if (T_3_3.num == true) {

  LINE(48);
            {
            elist[0] = STR_bad_040file_040format;
            {signal (ERR_not_possible);}}
            }
            }/* end if */

  LINE(50);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        locals.err = _wordvecOPfetch(locals.wv2, CLU_2, &T_3_1);
        if (locals.err != ERR_ok) goto ex_1;
        T_3_2.num = (T_3_1.num == 0)? true : false;
        T_3_3.num = T_3_2.num ^ 1;
        if (T_3_3.num == true) {

  LINE(53);
            {
            elist[0] = STR_bad_040file_040format;
            {signal (ERR_not_possible);}}
            }
            }/* end if */

  LINE(58);
        {
        locals.err = gcrOPpass1(locals.ch);
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(59);
        {
        locals.err = _chanOPclose(locals.ch);
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(62);
        {
        CLUREF T_3_1;
        locals.err = _chanOPopen(locals.fn, STR_read, CLU_0, &T_3_1);
        if (locals.err != ERR_ok) goto ex_1;
        locals.ch.num = T_3_1.num;
        }

  LINE(63);
        {
        CLUREF T_3_1;
        locals.err = _chanOPgetb(locals.ch, locals.bv8, &T_3_1);
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(64);
        {
        CLUREF T_3_1;
        locals.err = _chanOPgetb(locals.ch, locals.bv8, &T_3_1);
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(68);
        {
        locals.err = gcbOPinit();
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(69);
        {
        locals.err = gcrOPpass2(locals.ch);
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(70);
        {
        locals.err = _chanOPclose(locals.ch);
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(73);
        {
            {CLUREF T_3_1;
            CLUREF T_3_2;
            locals.err = gcoOPget_obj(CLU_0, &T_3_1);
            if (locals.err != ERR_ok) goto ex_1;
            T_3_2.num = T_3_1.num;
            locals.result.num = T_3_2.num;
            }
            }

  LINE(74);
        {
        locals.err = gcoOPreset();
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(75);
        {
        {
        ret_1->num = locals.result.num;
        }
        {signal (ERR_ok);}}
        }
        goto end_1;
        ex_1:
            {

  LINE(78);
                {
                locals.err = _chanOPclose(locals.ch);
                if (locals.err != ERR_ok) goto ex_0;
                }

  LINE(79);
                {
                elist[0] = STR_bad_040file_040format;
                {signal (ERR_not_possible);}}
            }
        end_1:;
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE gc_read ****/

extern struct OPS *string_ops;
extern struct OPS *_chan_ops;
extern struct OPS *_bytevec_ops;
extern struct OPS *_wordvec_ops;
extern struct OPS *file_name_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;
    Vlist9 *locals;
    Vlist0 *owns;
    Vlist0 *ptowns;
    Vlist2 *popowns;
    Slist0 *type_formals;
    Slist1 *op_formals;
    } dbg_info_gc_read_actual;
static Vlist1 vals_gc_read = {0, 1, { {0, 2, "", zero_ops, "t_ops"}}
};
static sig_desc1 sig_gc_read_1 = {0, 4, "not_possible", {0, 1
, { {0, 2, "", &string_ops}}}};
static siglist1 sigs_gc_read = {0, 1, (sig_desc*)&sig_gc_read_1};
static Vlist9 locals_gc_read = {0, 9,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "op_own_ptr", &int_ops},  {0, 2, "ch", &_chan_ops},  {0, 2, "why", &string_ops},  {0, 2, "bv8", &_bytevec_ops},  {0, 2, "wv2", &_wordvec_ops},  {0, 2, "result", zero_ops, "t_ops"},  {0, 2, "fn", &file_name_ops}}
};
static Vlist2 popowns_gc_read = {0, 2,{ {0, 2, "gc_read_init", &int_ops}
, {0, 2, "t_ops", &NULL_OPS}}};
Slist0 tformals_gc_read = {0, 0};
Slist1 opformals_gc_read = {0, 1, "t"};
dbg_info_gc_read_actual dbg_info_gc_read_data = {0, 12, 
    "gc_read", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 1, (int)gc_read, 1, 
    &vals_gc_read, &sigs_gc_read, &locals_gc_read, &NO_VALS, &NO_VALS, &popowns_gc_read, &NO_PARMS, &opformals_gc_read};
    struct dbg_info *dbg_info_gc_read = (struct dbg_info*)&dbg_info_gc_read_data;

/**** BEGIN CLUSTER gcr ****/

extern errcode gcr_IB_1();
extern errcode gcbOPget_next_hdr();
extern errcode gcrOPmake_bvec1();
extern errcode gcrOPmake_vec1();
extern errcode gcrOPmake_cell1();
extern errcode gcrOPmake_adv1();
extern errcode gcoOPsave_new_obj();
extern errcode gcbOPget_size();
extern errcode gcbOPgetb();
extern errcode _vecOPcreate();
extern errcode gcbOPskip_obj();
extern errcode _tagcellOPcreate();
extern errcode gcbOPgeti();
extern errcode gcbOPget_array_info();
extern errcode arrayOPpredict();
extern errcode gcrOPmake_bvec2();
extern errcode gcrOPmake_vec2();
extern errcode gcrOPmake_cell2();
extern errcode gcrOPmake_adv2();
extern errcode gcbOPskip();
extern errcode intOPdiv();
extern errcode intOPadd();
extern errcode intOPfrom_to();
extern errcode _vecOPstore();
extern errcode gcbOPget_next_obj();
extern errcode _tagcellOPset();
extern errcode intOPsub();
extern errcode _advOPset_vector();
extern errcode _advOPset_start();
extern errcode _advOPset_size();
extern errcode nullOPdebug_print();
extern struct REQS *_vec_of_t_reqs;
extern struct OPS *_obj_ops;
extern OWN_req _vec_ownreqs;
extern struct OPS *_vec_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 REQS *_tagcell_of_t_reqs;
extern OWN_req _tagcell_ownreqs;
extern struct OPS *_tagcell_ops;
struct OPS *_tagcell_of__obj_table;
struct OPS *_tagcell_of__obj_ops;
struct OPS *_tagcell_of__obj_ops;
OWNPTR _tagcell_of__obj_owns;
extern struct REQS *array_of_t_reqs;
extern OWN_req array_ownreqs;
extern struct OPS *array_ops;
struct OPS *array_of__obj_table;
struct OPS *array_of__obj_ops;
struct OPS *array_of__obj_ops;
OWNPTR array_of__obj_owns;
extern struct REQS *_adv_of_t_reqs;
extern OWN_req _adv_ownreqs;
extern struct OPS *_adv_ops;
struct OPS *_adv_of__obj_table;
struct OPS *_adv_of__obj_ops;
struct OPS *_adv_of__obj_ops;
OWNPTR _adv_of__obj_owns;
static int gcr_own_init = 0;
OWN_req gcr_ownreqs = {0,0};
errcode gcr_own_init_proc()
{
struct {
    errcode err;
    } locals;
    enter_own_init_proc();
        if (gcr_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_parm_info_type(0, _obj_ops, _tagcell_of_t_reqs);
        find_type_instance(_tagcell_ops, 1, &_tagcell_ownreqs, &(_tagcell_of__obj_ops));
        add_parm_info_type(0, _obj_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(array_of__obj_ops));
        add_parm_info_type(0, _obj_ops, _adv_of_t_reqs);
        find_type_instance(_adv_ops, 1, &_adv_ownreqs, &(_adv_of__obj_ops));
        stringOPcons("bad file format", CLU_1, CLU_15, &STR_bad_040file_040format);
        gcr_own_init = 1;
        {signal(ERR_ok);}
    ex_0: pclu_unhandled(locals.err); {signal(ERR_failure);}
        }
    }

extern struct dbg_info* dbg_info_gcrOPpass1;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcrOPpass1_TRACE
int gcrOPpass1_TRACE;
static Vlist12 owns_gcr = {0, 12,{ {0, 2, "gcr_init", &int_ops}
, {0, 2, "gcrOPpass1_init", &int_ops}
, {0, 2, "gcrOPpass1_init", &int_ops}
, {0, 2, "gcrOPpass1_init", &int_ops}
, {0, 2, "gcrOPpass1_init", &int_ops}
, {0, 2, "gcrOPpass1_init", &int_ops}
, {0, 2, "gcrOPpass1_init", &int_ops}
, {0, 2, "gcrOPpass1_init", &int_ops}
, {0, 2, "gcrOPpass1_init", &int_ops}
, {0, 2, "gcrOPpass1_init", &int_ops}
, {0, 2, "gcrOPpass1_init", &int_ops}
, {0, 2, "gcrOPpass1_init", &int_ops}
}
};
static int gcrOPpass1_own_init = 0;

/**** BEGIN PROCEDURE pass1 ****/

errcode gcrOPpass1(ch)
CLUREF ch;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF hdr;
        CLUREF id;
        CLUREF o;
        CLUREF ch;
        } locals;
    locals.hdr.num = UNINIT;
    locals.id.num = UNINIT;
    locals.o.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcrOPpass1;
    locals.ch = ch;
        if (gcrOPpass1_own_init == 0) {
        if (gcr_own_init == 0) {
            locals.err = gcr_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcrOPpass1_own_init = 1;
    }
    enter_proc(87);

  LINE(89);
    for (;;) {
        if (true != true) { break; }

  LINE(90);
        {
            {CLUREF T_3_1;
            CLUREF T_3_2;
            locals.err = gcbOPget_next_hdr(locals.ch, &T_3_1, &T_3_2);
            if (locals.err != ERR_ok) goto ex_1;
            locals.hdr.num = T_3_1.num;
            locals.id.num = T_3_2.num;
            }
            }
            goto end_1;
            ex_1:
                if ((locals.err == ERR_none)) {

  LINE(91);
                    {
                    {signal (ERR_ok);}}
                }
                else {
                    goto ex_0;
                }
            end_1:;

  LINE(92);
        {
        if (true == true) {
            }
            }/* end if */

  LINE(95);
        locals.o.num = UNINIT;

  LINE(96);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 8192;
        T_2_2.num = (locals.hdr.num == T_2_1.num)? true : false;
        if (T_2_2.num == true) {

  LINE(98);
            {
            if (true == true) {
                }
                }/* end if */

  LINE(101);
            {
            CLUREF T_3_1;
            locals.err = gcrOPmake_bvec1(locals.ch, &T_3_1);
            if (locals.err != ERR_ok) goto ex_0;
            locals.o.num = T_3_1.num;
            }
            }
        else {
        CLUREF T_2_3;
        CLUREF T_2_4;
        T_2_3.num = 4096;
        T_2_4.num = (locals.hdr.num == T_2_3.num)? true : false;
        if (T_2_4.num == true) {

  LINE(104);
            {
            if (true == true) {
                }
                }/* end if */

  LINE(107);
            {
            CLUREF T_3_1;
            locals.err = gcrOPmake_vec1(locals.ch, &T_3_1);
            if (locals.err != ERR_ok) goto ex_0;
            locals.o.num = T_3_1.num;
            }
            }
        else {
        CLUREF T_2_5;
        CLUREF T_2_6;
        T_2_5.num = 16384;
        T_2_6.num = (locals.hdr.num == T_2_5.num)? true : false;
        if (T_2_6.num == true) {

  LINE(110);
            {
            if (true == true) {
                }
                }/* end if */

  LINE(113);
            {
            CLUREF T_3_1;
            locals.err = gcrOPmake_cell1(locals.ch, &T_3_1);
            if (locals.err != ERR_ok) goto ex_0;
            locals.o.num = T_3_1.num;
            }
            }
        else {
        CLUREF T_2_7;
        CLUREF T_2_8;
        T_2_7.num = 24576;
        T_2_8.num = (locals.hdr.num == T_2_7.num)? true : false;
        if (T_2_8.num == true) {

  LINE(116);
            {
            if (true == true) {

  LINE(119);
                {
                CLUREF T_4_1;
                locals.err = gcrOPmake_adv1(locals.ch, &T_4_1);
                if (locals.err != ERR_ok) goto ex_0;
                locals.o.num = T_4_1.num;
                }
                }
                }/* end if */
            }
        else {

  LINE(122);
            {
            elist[0] = STR_bad_040file_040format;
            {signal (ERR_not_possible);}}
            }}}}}/* end if */

  LINE(124);
        {
        locals.err = gcoOPsave_new_obj(locals.id, locals.o);
        if (locals.err != ERR_ok) goto ex_0;
        }
        }
        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 pass1 ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist1 *sigs;
    Vlist6 *locals;
    Vlist12 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcrOPpass1_actual;
static Vlist0 vals_gcrOPpass1 = {0, 0};
static sig_desc1 sig_gcrOPpass1_1 = {0, 4, "not_possible", {0, 1
, { {0, 2, "", &string_ops}}}};
static siglist1 sigs_gcrOPpass1 = {0, 1, (sig_desc*)&sig_gcrOPpass1_1};
static Vlist6 locals_gcrOPpass1 = {0, 6,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "hdr", &int_ops},  {0, 2, "id", &int_ops},  {0, 2, "o", &_obj_ops},  {0, 2, "ch", &_chan_ops}}
};
static Vlist0 popowns_gcrOPpass1 = {0, 0};
Slist0 tformals_gcrOPpass1 = {0, 0};
Slist0 opformals_gcrOPpass1 = {0, 0};
dbg_info_gcrOPpass1_actual dbg_info_gcrOPpass1_data = {0, 12, 
    "gcrOPpass1", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcrOPpass1, 1, 
    &vals_gcrOPpass1, &sigs_gcrOPpass1, &locals_gcrOPpass1, &owns_gcr, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcrOPpass1 = (struct dbg_info*)&dbg_info_gcrOPpass1_data;
extern struct dbg_info* dbg_info_gcrOPmake_bvec1;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcrOPmake_bvec1_TRACE
int gcrOPmake_bvec1_TRACE;
static int gcrOPmake_bvec1_own_init = 0;

/**** BEGIN PROCEDURE make_bvec1 ****/

errcode gcrOPmake_bvec1(ch, ret_1)
CLUREF ch;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF size;
        CLUREF bv;
        CLUREF ch;
        } locals;
    locals.size.num = UNINIT;
    locals.bv.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcrOPmake_bvec1;
    locals.ch = ch;
        if (gcrOPmake_bvec1_own_init == 0) {
        if (gcr_own_init == 0) {
            locals.err = gcr_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcrOPmake_bvec1_own_init = 1;
    }
    enter_proc(129);

  LINE(130);
    {
        {CLUREF T_1_1;
        locals.err = gcbOPget_size(locals.ch, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.size.num = T_1_1.num;
        }
        }

  LINE(131);
    {
        {CLUREF T_1_1;
        locals.err = _bytevecOPcreate(locals.size, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.bv.num = T_1_1.num;
        }
        }

  LINE(132);
    {
    locals.err = gcbOPgetb(locals.ch, locals.bv);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(133);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.bv.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 make_bvec1 ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist5 *locals;
    Vlist12 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcrOPmake_bvec1_actual;
static Vlist1 vals_gcrOPmake_bvec1 = {0, 1, { {0, 2, "", &_obj_ops}}
};
static siglist0 sigs_gcrOPmake_bvec1 = {0, 0};
static Vlist5 locals_gcrOPmake_bvec1 = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "size", &int_ops},  {0, 2, "bv", &_bytevec_ops},  {0, 2, "ch", &_chan_ops}}
};
static Vlist0 popowns_gcrOPmake_bvec1 = {0, 0};
Slist0 tformals_gcrOPmake_bvec1 = {0, 0};
Slist0 opformals_gcrOPmake_bvec1 = {0, 0};
dbg_info_gcrOPmake_bvec1_actual dbg_info_gcrOPmake_bvec1_data = {0, 12, 
    "gcrOPmake_bvec1", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcrOPmake_bvec1, 1, 
    &vals_gcrOPmake_bvec1, &sigs_gcrOPmake_bvec1, &locals_gcrOPmake_bvec1, &owns_gcr, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcrOPmake_bvec1 = (struct dbg_info*)&dbg_info_gcrOPmake_bvec1_data;
extern struct dbg_info* dbg_info_gcrOPmake_vec1;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcrOPmake_vec1_TRACE
int gcrOPmake_vec1_TRACE;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
static int gcrOPmake_vec1_own_init = 0;

/**** BEGIN PROCEDURE make_vec1 ****/

errcode gcrOPmake_vec1(ch, ret_1)
CLUREF ch;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF size;
        CLUREF v;
        CLUREF ch;
        } locals;
    locals.size.num = UNINIT;
    locals.v.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcrOPmake_vec1;
    locals.ch = ch;
        if (gcrOPmake_vec1_own_init == 0) {
        if (gcr_own_init == 0) {
            locals.err = gcr_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcrOPmake_vec1_own_init = 1;
    }
    enter_proc(136);

  LINE(137);
    {
        {CLUREF T_1_1;
        locals.err = gcbOPget_size(locals.ch, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.size.num = T_1_1.num;
        }
        }

  LINE(138);
    {
        {CLUREF T_1_1;
        locals.err = _vecOPcreate(locals.size, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.v.num = T_1_1.num;
        }
        }

  LINE(139);
    {
    locals.err = gcbOPskip_obj(locals.ch, locals.size);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(140);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.v.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 make_vec1 ****/

extern struct OPS *_vec_of__obj_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;
    Vlist5 *locals;
    Vlist12 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcrOPmake_vec1_actual;
static Vlist1 vals_gcrOPmake_vec1 = {0, 1, { {0, 2, "", &_obj_ops}}
};
static siglist0 sigs_gcrOPmake_vec1 = {0, 0};
static Vlist5 locals_gcrOPmake_vec1 = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "size", &int_ops},  {0, 2, "v", &_vec_of__obj_ops},  {0, 2, "ch", &_chan_ops}}
};
static Vlist0 popowns_gcrOPmake_vec1 = {0, 0};
Slist0 tformals_gcrOPmake_vec1 = {0, 0};
Slist0 opformals_gcrOPmake_vec1 = {0, 0};
dbg_info_gcrOPmake_vec1_actual dbg_info_gcrOPmake_vec1_data = {0, 12, 
    "gcrOPmake_vec1", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcrOPmake_vec1, 1, 
    &vals_gcrOPmake_vec1, &sigs_gcrOPmake_vec1, &locals_gcrOPmake_vec1, &owns_gcr, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcrOPmake_vec1 = (struct dbg_info*)&dbg_info_gcrOPmake_vec1_data;
extern struct dbg_info* dbg_info_gcrOPmake_cell1;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcrOPmake_cell1_TRACE
int gcrOPmake_cell1_TRACE;
extern OWN_req _obj_ownreqs;
struct OPS *_tagcell_of__obj_table;
struct OPS *_tagcell_of__obj_ops;
struct OPS *_tagcell_of__obj_ops;
OWNPTR _tagcell_of__obj_owns;
static int gcrOPmake_cell1_own_init = 0;

/**** BEGIN PROCEDURE make_cell1 ****/

errcode gcrOPmake_cell1(ch, ret_1)
CLUREF ch;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        CLUREF ch;
        } locals;
    locals.t.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcrOPmake_cell1;
    locals.ch = ch;
        if (gcrOPmake_cell1_own_init == 0) {
        if (gcr_own_init == 0) {
            locals.err = gcr_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcrOPmake_cell1_own_init = 1;
    }
    enter_proc(143);

  LINE(144);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        T_1_1.num = 0;
        generic_CLU_proc.type_owns = _tagcell_of__obj_ops->type_owns;
        generic_CLU_proc.proc = _tagcellOPcreate;
        CUR_PROC_VAR.proc = &generic_CLU_proc;
        locals.err = _tagcellOPcreate(CLU_0, T_1_1, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.t.num = T_1_2.num;
        }
        }

  LINE(145);
    {
    CLUREF T_1_1;
    locals.err = gcbOPgeti(locals.ch, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(146);
    {
    locals.err = gcbOPskip_obj(locals.ch, CLU_1);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(147);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.t.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 make_cell1 ****/

extern struct OPS *_tagcell_of__obj_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist12 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcrOPmake_cell1_actual;
static Vlist1 vals_gcrOPmake_cell1 = {0, 1, { {0, 2, "", &_obj_ops}}
};
static siglist0 sigs_gcrOPmake_cell1 = {0, 0};
static Vlist4 locals_gcrOPmake_cell1 = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &_tagcell_of__obj_ops},  {0, 2, "ch", &_chan_ops}}
};
static Vlist0 popowns_gcrOPmake_cell1 = {0, 0};
Slist0 tformals_gcrOPmake_cell1 = {0, 0};
Slist0 opformals_gcrOPmake_cell1 = {0, 0};
dbg_info_gcrOPmake_cell1_actual dbg_info_gcrOPmake_cell1_data = {0, 12, 
    "gcrOPmake_cell1", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcrOPmake_cell1, 1, 
    &vals_gcrOPmake_cell1, &sigs_gcrOPmake_cell1, &locals_gcrOPmake_cell1, &owns_gcr, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcrOPmake_cell1 = (struct dbg_info*)&dbg_info_gcrOPmake_cell1_data;
extern struct dbg_info* dbg_info_gcrOPmake_adv1;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcrOPmake_adv1_TRACE
int gcrOPmake_adv1_TRACE;
struct OPS *array_of__obj_table;
struct OPS *array_of__obj_ops;
struct OPS *array_of__obj_ops;
OWNPTR array_of__obj_owns;
static int gcrOPmake_adv1_own_init = 0;

/**** BEGIN PROCEDURE make_adv1 ****/

errcode gcrOPmake_adv1(ch, ret_1)
CLUREF ch;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF size;
        CLUREF ext_size;
        CLUREF ext_low;
        CLUREF int_low;
        CLUREF int_size;
        CLUREF a;
        CLUREF ch;
        } locals;
    locals.size.num = UNINIT;
    locals.ext_size.num = UNINIT;
    locals.ext_low.num = UNINIT;
    locals.int_low.num = UNINIT;
    locals.int_size.num = UNINIT;
    locals.a.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcrOPmake_adv1;
    locals.ch = ch;
        if (gcrOPmake_adv1_own_init == 0) {
        if (gcr_own_init == 0) {
            locals.err = gcr_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcrOPmake_adv1_own_init = 1;
    }
    enter_proc(150);

  LINE(151);
    {
        {CLUREF T_1_1;
        locals.err = gcbOPget_size(locals.ch, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.size.num = T_1_1.num;
        }
        }

  LINE(152);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        locals.err = gcbOPget_array_info(locals.ch, &T_1_1, &T_1_2, &T_1_3, &T_1_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.ext_size.num = T_1_1.num;
        locals.ext_low.num = T_1_2.num;
        locals.int_low.num = T_1_3.num;
        locals.int_size.num = T_1_4.num;
        }
        }

  LINE(153);
    {
        {CLUREF T_1_1;
        locals.err = arrayOPpredict(locals.ext_low, locals.int_size, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.a.num = T_1_1.num;
        }
        }

  LINE(154);
    {
    locals.err = gcbOPskip_obj(locals.ch, CLU_1);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(155);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.a.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 make_adv1 ****/

extern struct OPS *array_of__obj_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;
    Vlist12 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcrOPmake_adv1_actual;
static Vlist1 vals_gcrOPmake_adv1 = {0, 1, { {0, 2, "", &_obj_ops}}
};
static siglist0 sigs_gcrOPmake_adv1 = {0, 0};
static Vlist9 locals_gcrOPmake_adv1 = {0, 9,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "size", &int_ops},  {0, 2, "ext_size", &int_ops},  {0, 2, "ext_low", &int_ops},  {0, 2, "int_low", &int_ops},  {0, 2, "int_size", &int_ops},  {0, 2, "a", &array_of__obj_ops},  {0, 2, "ch", &_chan_ops}}
};
static Vlist0 popowns_gcrOPmake_adv1 = {0, 0};
Slist0 tformals_gcrOPmake_adv1 = {0, 0};
Slist0 opformals_gcrOPmake_adv1 = {0, 0};
dbg_info_gcrOPmake_adv1_actual dbg_info_gcrOPmake_adv1_data = {0, 12, 
    "gcrOPmake_adv1", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcrOPmake_adv1, 1, 
    &vals_gcrOPmake_adv1, &sigs_gcrOPmake_adv1, &locals_gcrOPmake_adv1, &owns_gcr, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcrOPmake_adv1 = (struct dbg_info*)&dbg_info_gcrOPmake_adv1_data;
extern struct dbg_info* dbg_info_gcrOPpass2;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcrOPpass2_TRACE
int gcrOPpass2_TRACE;
static int gcrOPpass2_own_init = 0;

/**** BEGIN PROCEDURE pass2 ****/

errcode gcrOPpass2(ch)
CLUREF ch;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF hdr;
        CLUREF id;
        CLUREF o;
        CLUREF ch;
        } locals;
    locals.hdr.num = UNINIT;
    locals.id.num = UNINIT;
    locals.o.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcrOPpass2;
    locals.ch = ch;
        if (gcrOPpass2_own_init == 0) {
        if (gcr_own_init == 0) {
            locals.err = gcr_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcrOPpass2_own_init = 1;
    }
    enter_proc(158);

  LINE(160);
    for (;;) {
        if (true != true) { break; }

  LINE(161);
        {
            {CLUREF T_3_1;
            CLUREF T_3_2;
            locals.err = gcbOPget_next_hdr(locals.ch, &T_3_1, &T_3_2);
            if (locals.err != ERR_ok) goto ex_1;
            locals.hdr.num = T_3_1.num;
            locals.id.num = T_3_2.num;
            }
            }
            goto end_1;
            ex_1:
                if ((locals.err == ERR_none)) {

  LINE(162);
                    {
                    {signal (ERR_ok);}}
                }
                else {
                    goto ex_0;
                }
            end_1:;

  LINE(164);
        {
            {CLUREF T_2_1;
            locals.err = gcoOPget_obj(locals.id, &T_2_1);
            if (locals.err != ERR_ok) goto ex_0;
            locals.o.num = T_2_1.num;
            }
            }

  LINE(165);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 8192;
        T_2_2.num = (locals.hdr.num == T_2_1.num)? true : false;
        if (T_2_2.num == true) {

  LINE(168);
            {
            locals.err = gcrOPmake_bvec2(locals.ch, locals.o);
            if (locals.err != ERR_ok) goto ex_0;
            }
            }
        else {
        CLUREF T_2_3;
        CLUREF T_2_4;
        T_2_3.num = 4096;
        T_2_4.num = (locals.hdr.num == T_2_3.num)? true : false;
        if (T_2_4.num == true) {

  LINE(171);
            {
            locals.err = gcrOPmake_vec2(locals.ch, locals.o);
            if (locals.err != ERR_ok) goto ex_0;
            }
            }
        else {
        CLUREF T_2_5;
        CLUREF T_2_6;
        T_2_5.num = 16384;
        T_2_6.num = (locals.hdr.num == T_2_5.num)? true : false;
        if (T_2_6.num == true) {

  LINE(174);
            {
            locals.err = gcrOPmake_cell2(locals.ch, locals.o);
            if (locals.err != ERR_ok) goto ex_0;
            }
            }
        else {
        CLUREF T_2_7;
        CLUREF T_2_8;
        T_2_7.num = 24576;
        T_2_8.num = (locals.hdr.num == T_2_7.num)? true : false;
        if (T_2_8.num == true) {

  LINE(177);
            {
            locals.err = gcrOPmake_adv2(locals.ch, locals.o);
            if (locals.err != ERR_ok) goto ex_0;
            }
            }
        else {

  LINE(179);
            {
            elist[0] = STR_bad_040file_040format;
            {signal (ERR_not_possible);}}
            }}}}}/* end if */
        }
        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 pass2 ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist1 *sigs;
    Vlist6 *locals;
    Vlist12 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcrOPpass2_actual;
static Vlist0 vals_gcrOPpass2 = {0, 0};
static sig_desc1 sig_gcrOPpass2_1 = {0, 4, "not_possible", {0, 1
, { {0, 2, "", &string_ops}}}};
static siglist1 sigs_gcrOPpass2 = {0, 1, (sig_desc*)&sig_gcrOPpass2_1};
static Vlist6 locals_gcrOPpass2 = {0, 6,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "hdr", &int_ops},  {0, 2, "id", &int_ops},  {0, 2, "o", &_obj_ops},  {0, 2, "ch", &_chan_ops}}
};
static Vlist0 popowns_gcrOPpass2 = {0, 0};
Slist0 tformals_gcrOPpass2 = {0, 0};
Slist0 opformals_gcrOPpass2 = {0, 0};
dbg_info_gcrOPpass2_actual dbg_info_gcrOPpass2_data = {0, 12, 
    "gcrOPpass2", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcrOPpass2, 1, 
    &vals_gcrOPpass2, &sigs_gcrOPpass2, &locals_gcrOPpass2, &owns_gcr, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcrOPpass2 = (struct dbg_info*)&dbg_info_gcrOPpass2_data;
extern struct dbg_info* dbg_info_gcrOPmake_bvec2;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcrOPmake_bvec2_TRACE
int gcrOPmake_bvec2_TRACE;
static int gcrOPmake_bvec2_own_init = 0;

/**** BEGIN PROCEDURE make_bvec2 ****/

errcode gcrOPmake_bvec2(ch, o)
CLUREF ch;
CLUREF o;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF size;
        CLUREF ch;
        CLUREF o;
        } locals;
    locals.size.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.o.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcrOPmake_bvec2;
    locals.ch = ch;
    locals.o = o;
        if (gcrOPmake_bvec2_own_init == 0) {
        if (gcr_own_init == 0) {
            locals.err = gcr_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcrOPmake_bvec2_own_init = 1;
    }
    enter_proc(185);

  LINE(186);
    {
        {CLUREF T_1_1;
        locals.err = gcbOPget_size(locals.ch, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.size.num = T_1_1.num;
        }
        }

  LINE(187);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    locals.err = intOPadd(locals.size, CLU_4, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = intOPdiv(T_1_1, CLU_4, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = gcbOPskip(locals.ch, T_1_2);
    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 make_bvec2 ****/

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;
    Vlist12 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcrOPmake_bvec2_actual;
static Vlist0 vals_gcrOPmake_bvec2 = {0, 0};
static siglist0 sigs_gcrOPmake_bvec2 = {0, 0};
static Vlist5 locals_gcrOPmake_bvec2 = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "size", &int_ops},  {0, 2, "ch", &_chan_ops},  {0, 2, "o", &_obj_ops}}
};
static Vlist0 popowns_gcrOPmake_bvec2 = {0, 0};
Slist0 tformals_gcrOPmake_bvec2 = {0, 0};
Slist0 opformals_gcrOPmake_bvec2 = {0, 0};
dbg_info_gcrOPmake_bvec2_actual dbg_info_gcrOPmake_bvec2_data = {0, 12, 
    "gcrOPmake_bvec2", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcrOPmake_bvec2, 2, 
    &vals_gcrOPmake_bvec2, &sigs_gcrOPmake_bvec2, &locals_gcrOPmake_bvec2, &owns_gcr, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcrOPmake_bvec2 = (struct dbg_info*)&dbg_info_gcrOPmake_bvec2_data;
extern struct dbg_info* dbg_info_gcrOPmake_vec2;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcrOPmake_vec2_TRACE
int gcrOPmake_vec2_TRACE;
extern errcode gcrOPmake_vec2_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;
static int gcrOPmake_vec2_own_init = 0;

/**** BEGIN PROCEDURE make_vec2 ****/

errcode gcrOPmake_vec2(ch, o)
CLUREF ch;
CLUREF o;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF size;
        CLUREF v;
        CLUREF i;
        CLUREF ch;
        CLUREF o;
        } locals;
    locals.size.num = UNINIT;
    locals.v.num = UNINIT;
    locals.i.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.o.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcrOPmake_vec2;
    locals.ch = ch;
    locals.o = o;
        if (gcrOPmake_vec2_own_init == 0) {
        if (gcr_own_init == 0) {
            locals.err = gcr_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcrOPmake_vec2_own_init = 1;
    }
    enter_proc(190);

  LINE(191);
    {
        {CLUREF T_1_1;
        locals.err = gcbOPget_size(locals.ch, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.size.num = T_1_1.num;
        }
        }

  LINE(192);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.o.num;
        locals.v.num = T_1_1.num;
        }
        }

  LINE(193);
    {
        locals.err = intOPfrom_to(CLU_1, locals.size, gcrOPmake_vec2_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 make_vec2 ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist7 *locals;
    Vlist12 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcrOPmake_vec2_actual;
static Vlist0 vals_gcrOPmake_vec2 = {0, 0};
static siglist0 sigs_gcrOPmake_vec2 = {0, 0};
static Vlist7 locals_gcrOPmake_vec2 = {0, 7,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "size", &int_ops},  {0, 2, "v", &_vec_of__obj_ops},  {0, 2, "i", &int_ops},  {0, 2, "ch", &_chan_ops},  {0, 2, "o", &_obj_ops}}
};
static Vlist0 popowns_gcrOPmake_vec2 = {0, 0};
Slist0 tformals_gcrOPmake_vec2 = {0, 0};
Slist0 opformals_gcrOPmake_vec2 = {0, 0};
dbg_info_gcrOPmake_vec2_actual dbg_info_gcrOPmake_vec2_data = {0, 12, 
    "gcrOPmake_vec2", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcrOPmake_vec2, 2, 
    &vals_gcrOPmake_vec2, &sigs_gcrOPmake_vec2, &locals_gcrOPmake_vec2, &owns_gcr, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcrOPmake_vec2 = (struct dbg_info*)&dbg_info_gcrOPmake_vec2_data;

/**** BEGIN ITERATOR BODIES for make_vec2 ****/

errcode gcrOPmake_vec2_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF size;
    CLUREF v;
    CLUREF i;
    CLUREF ch;
    CLUREF o;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(194);

  FB_LINE(194);
    {
    CLUREF T_1_1;
    locals->err = gcbOPget_next_obj(locals->ch, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->err = _vecOPstore(locals->v, 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 gcrOPmake_vec2_IB_1 */

/**** END ITERATOR BODIES for make_vec2 ****/

extern struct dbg_info* dbg_info_gcrOPmake_cell2;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcrOPmake_cell2_TRACE
int gcrOPmake_cell2_TRACE;
struct OPS *_tagcell_of__obj_table;
struct OPS *_tagcell_of__obj_ops;
struct OPS *_tagcell_of__obj_ops;
OWNPTR _tagcell_of__obj_owns;
static int gcrOPmake_cell2_own_init = 0;

/**** BEGIN PROCEDURE make_cell2 ****/

errcode gcrOPmake_cell2(ch, o)
CLUREF ch;
CLUREF o;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        CLUREF tg;
        CLUREF ch;
        CLUREF o;
        } locals;
    locals.t.num = UNINIT;
    locals.tg.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.o.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcrOPmake_cell2;
    locals.ch = ch;
    locals.o = o;
        if (gcrOPmake_cell2_own_init == 0) {
        if (gcr_own_init == 0) {
            locals.err = gcr_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcrOPmake_cell2_own_init = 1;
    }
    enter_proc(198);

  LINE(199);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.o.num;
        locals.t.num = T_1_1.num;
        }
        }

  LINE(200);
    {
        {CLUREF T_1_1;
        locals.err = gcbOPgeti(locals.ch, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.tg.num = T_1_1.num;
        }
        }

  LINE(201);
    {
    CLUREF T_1_1;
    locals.err = gcbOPget_next_obj(locals.ch, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    generic_CLU_proc.type_owns = _tagcell_of__obj_ops->type_owns;
    generic_CLU_proc.proc = _tagcellOPset;
    CUR_PROC_VAR.proc = &generic_CLU_proc;
    locals.err = _tagcellOPset(locals.t, locals.tg, T_1_1);
    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 make_cell2 ****/

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;
    Vlist12 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcrOPmake_cell2_actual;
static Vlist0 vals_gcrOPmake_cell2 = {0, 0};
static siglist0 sigs_gcrOPmake_cell2 = {0, 0};
static Vlist6 locals_gcrOPmake_cell2 = {0, 6,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &_tagcell_of__obj_ops},  {0, 2, "tg", &int_ops},  {0, 2, "ch", &_chan_ops},  {0, 2, "o", &_obj_ops}}
};
static Vlist0 popowns_gcrOPmake_cell2 = {0, 0};
Slist0 tformals_gcrOPmake_cell2 = {0, 0};
Slist0 opformals_gcrOPmake_cell2 = {0, 0};
dbg_info_gcrOPmake_cell2_actual dbg_info_gcrOPmake_cell2_data = {0, 12, 
    "gcrOPmake_cell2", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcrOPmake_cell2, 2, 
    &vals_gcrOPmake_cell2, &sigs_gcrOPmake_cell2, &locals_gcrOPmake_cell2, &owns_gcr, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcrOPmake_cell2 = (struct dbg_info*)&dbg_info_gcrOPmake_cell2_data;
extern struct dbg_info* dbg_info_gcrOPmake_adv2;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcrOPmake_adv2_TRACE
int gcrOPmake_adv2_TRACE;
extern OWN_req int_ownreqs;
struct OPS *_adv_of__obj_table;
struct OPS *_adv_of__obj_ops;
struct OPS *_adv_of__obj_ops;
OWNPTR _adv_of__obj_owns;
struct OPS *_vec_of__obj_table;
struct OPS *_vec_of__obj_ops;
struct OPS *_vec_of__obj_ops;
OWNPTR _vec_of__obj_owns;
static int gcrOPmake_adv2_own_init = 0;

/**** BEGIN PROCEDURE make_adv2 ****/

errcode gcrOPmake_adv2(ch, o)
CLUREF ch;
CLUREF o;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF size;
        CLUREF a;
        CLUREF j1;
        CLUREF j2;
        CLUREF j3;
        CLUREF j4;
        CLUREF v;
        CLUREF ch;
        CLUREF o;
        } locals;
    locals.size.num = UNINIT;
    locals.a.num = UNINIT;
    locals.j1.num = UNINIT;
    locals.j2.num = UNINIT;
    locals.j3.num = UNINIT;
    locals.j4.num = UNINIT;
    locals.v.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.o.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcrOPmake_adv2;
    locals.ch = ch;
    locals.o = o;
        if (gcrOPmake_adv2_own_init == 0) {
        if (gcr_own_init == 0) {
            locals.err = gcr_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcrOPmake_adv2_own_init = 1;
    }
    enter_proc(204);

  LINE(205);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        locals.err = gcbOPget_size(locals.ch, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPsub(T_1_1, CLU_8, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.size.num = T_1_2.num;
        }
        }

  LINE(206);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.o.num;
        locals.a.num = T_1_1.num;
        }
        }

  LINE(207);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        locals.err = gcbOPget_array_info(locals.ch, &T_1_1, &T_1_2, &T_1_3, &T_1_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.j1.num = T_1_1.num;
        locals.j2.num = T_1_2.num;
        locals.j3.num = T_1_3.num;
        locals.j4.num = T_1_4.num;
        }
        }

  LINE(209);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        locals.err = gcbOPget_next_obj(locals.ch, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        T_1_2.num = T_1_1.num;
        locals.v.num = T_1_2.num;
        }
        }

  LINE(211);
    {
    generic_CLU_proc.type_owns = _adv_of__obj_ops->type_owns;
    generic_CLU_proc.proc = _advOPset_vector;
    CUR_PROC_VAR.proc = &generic_CLU_proc;
    locals.err = _advOPset_vector(locals.a, locals.v);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(213);
    {
    generic_CLU_proc.type_owns = _adv_of__obj_ops->type_owns;
    generic_CLU_proc.proc = _advOPset_start;
    CUR_PROC_VAR.proc = &generic_CLU_proc;
    locals.err = _advOPset_start(locals.a, locals.j3);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(214);
    {
    generic_CLU_proc.type_owns = _adv_of__obj_ops->type_owns;
    generic_CLU_proc.proc = _advOPset_size;
    CUR_PROC_VAR.proc = &generic_CLU_proc;
    locals.err = _advOPset_size(locals.a, locals.j1);
    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 make_adv2 ****/

extern struct OPS *_adv_of__obj_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;
    Vlist12 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcrOPmake_adv2_actual;
static Vlist0 vals_gcrOPmake_adv2 = {0, 0};
static siglist0 sigs_gcrOPmake_adv2 = {0, 0};
static Vlist11 locals_gcrOPmake_adv2 = {0, 11,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "size", &int_ops},  {0, 2, "a", &_adv_of__obj_ops},  {0, 2, "j1", &int_ops},  {0, 2, "j2", &int_ops},  {0, 2, "j3", &int_ops},  {0, 2, "j4", &int_ops},  {0, 2, "v", &_vec_of__obj_ops},  {0, 2, "ch", &_chan_ops},  {0, 2, "o", &_obj_ops}}
};
static Vlist0 popowns_gcrOPmake_adv2 = {0, 0};
Slist0 tformals_gcrOPmake_adv2 = {0, 0};
Slist0 opformals_gcrOPmake_adv2 = {0, 0};
dbg_info_gcrOPmake_adv2_actual dbg_info_gcrOPmake_adv2_data = {0, 12, 
    "gcrOPmake_adv2", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcrOPmake_adv2, 2, 
    &vals_gcrOPmake_adv2, &sigs_gcrOPmake_adv2, &locals_gcrOPmake_adv2, &owns_gcr, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcrOPmake_adv2 = (struct dbg_info*)&dbg_info_gcrOPmake_adv2_data;
extern struct dbg_info* dbg_info_gcrOPdebug_print;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcrOPdebug_print_TRACE
int gcrOPdebug_print_TRACE;
extern OWN_req null_ownreqs;
extern struct OPS *null_ops;
static int gcrOPdebug_print_own_init = 0;

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

errcode gcrOPdebug_print(_rep, ps)
CLUREF _rep;
CLUREF ps;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF _rep;
        CLUREF ps;
        } locals;
    locals._rep.num = UNINIT;
    locals.ps.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcrOPdebug_print;
    locals._rep = _rep;
    locals.ps = ps;
        if (gcrOPdebug_print_own_init == 0) {
        if (gcr_own_init == 0) {
            locals.err = gcr_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcrOPdebug_print_own_init = 1;
    }
    enter_proc(1);

  LINE(2);
    {
    locals.err = nullOPdebug_print(locals._rep, locals.ps);
    if (locals.err != ERR_ok) goto ex_0;
    }
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

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

extern struct OPS *pstream_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist12 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcrOPdebug_print_actual;
static Vlist0 vals_gcrOPdebug_print = {0, 0};
static siglist0 sigs_gcrOPdebug_print = {0, 0};
static Vlist4 locals_gcrOPdebug_print = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "_rep", &null_ops},  {0, 2, "ps", &pstream_ops}}
};
static Vlist0 popowns_gcrOPdebug_print = {0, 0};
Slist0 tformals_gcrOPdebug_print = {0, 0};
Slist0 opformals_gcrOPdebug_print = {0, 0};
dbg_info_gcrOPdebug_print_actual dbg_info_gcrOPdebug_print_data = {0, 12, 
    "gcrOPdebug_print", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcrOPdebug_print, 2, 
    &vals_gcrOPdebug_print, &sigs_gcrOPdebug_print, &locals_gcrOPdebug_print, &owns_gcr, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcrOPdebug_print = (struct dbg_info*)&dbg_info_gcrOPdebug_print_data;
typedef struct{
    int count;
    OWNPTR type_owns;
    OWNPTR op_owns;
    struct OP_ENTRY entry[3];
} gcr_OPS;

CLU_proc gcr_oe_pass1 = {{0,0,0,0}, gcrOPpass1, 0};
CLU_proc gcr_oe_pass2 = {{0,0,0,0}, gcrOPpass2, 0};
CLU_proc gcr_oe_debug_print = {{0,0,0,0}, gcrOPdebug_print, 0};

gcr_OPS gcr_ops_actual = {3, (OWNPTR)&gcr_own_init, (OWNPTR)&gcr_own_init, {
    {&gcr_oe_pass1, "pass1"},
    {&gcr_oe_pass2, "pass2"},
    {&gcr_oe_debug_print, "debug_print"}}};

struct OPS *gcr_ops = (struct OPS *)&gcr_ops_actual;

/**** END CLUSTER gcr ****/

/**** BEGIN CLUSTER gcb ****/

extern errcode gcb_IB_1();
extern errcode _wordvecOPcreate();
extern errcode _chanOPgetw();
extern errcode _bytevecOPsize();
extern errcode intOPmul();
extern errcode intOPlt();
extern errcode intOPmin();
extern errcode _wordvecOPmove_w2b();
extern OWN_req _wordvec_ownreqs;
CLUREF STR_bad_040format_040file;
static int gcb_own_init = 0;
OWN_req gcb_ownreqs = {0,0};
CLUREF gcbOPlookahead;
CLUREF gcbOPlook_index;
CLUREF gcbOPlook_count;
CLUREF gcbOPscratch;
CLUREF gcbOPobj_addr;
CLUREF gcbOPwv1;
errcode gcb_own_init_proc()
{
struct {
    errcode err;
    } locals;
    enter_own_init_proc();
        if (gcb_own_init == 0) {
        stringOPcons("bad format file", CLU_1, CLU_15, &STR_bad_040format_040file);
        gcb_own_init = 1;
        {
            {CLUREF T_0_1;
            CLUREF T_0_2;
            T_0_1.num = 4096;
            locals.err = _wordvecOPcreate(T_0_1, &T_0_2);
            if (locals.err != ERR_ok) goto ex_0;
            gcbOPlookahead.num = T_0_2.num;
            }
            }
        {
            {gcbOPlook_index.num = 0;
            }
            }
        {
            {gcbOPlook_count.num = 0;
            }
            }
        {
            {CLUREF T_0_3;
            CLUREF T_0_4;
            T_0_3.num = 4096;
            locals.err = _bytevecOPcreate(T_0_3, &T_0_4);
            if (locals.err != ERR_ok) goto ex_0;
            gcbOPscratch.num = T_0_4.num;
            }
            }
        {
            {gcbOPobj_addr.num = 0;
            }
            }
        {
            {CLUREF T_0_5;
            locals.err = _wordvecOPcreate(CLU_1, &T_0_5);
            if (locals.err != ERR_ok) goto ex_0;
            gcbOPwv1.num = T_0_5.num;
            }
            }
        {signal(ERR_ok);}
    ex_0: pclu_unhandled(locals.err); {signal(ERR_failure);}
        }
    }

extern struct dbg_info* dbg_info_gcbOPinit;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcbOPinit_TRACE
int gcbOPinit_TRACE;
static Vlist17 owns_gcb = {0, 17,{ {0, 2, "gcb_init", &int_ops}
,  {0, 2, "lookahead", &_wordvec_ops},  {0, 2, "look_index", &int_ops},  {0, 2, "look_count", &int_ops},  {0, 2, "scratch", &_bytevec_ops},  {0, 2, "obj_addr", &int_ops},  {0, 2, "wv1", &_wordvec_ops}, {0, 2, "gcbOPinit_init", &int_ops}
, {0, 2, "gcbOPinit_init", &int_ops}
, {0, 2, "gcbOPinit_init", &int_ops}
, {0, 2, "gcbOPinit_init", &int_ops}
, {0, 2, "gcbOPinit_init", &int_ops}
, {0, 2, "gcbOPinit_init", &int_ops}
, {0, 2, "gcbOPinit_init", &int_ops}
, {0, 2, "gcbOPinit_init", &int_ops}
, {0, 2, "gcbOPinit_init", &int_ops}
, {0, 2, "gcbOPinit_init", &int_ops}
}
};

/**** BEGIN PROCEDURE init ****/

errcode gcbOPinit()
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        } locals;
    locals.DBG_INFO = dbg_info_gcbOPinit;
        if (gcb_own_init == 0) {
            locals.err = gcb_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
    enter_proc(231);

  LINE(232);
    {
    gcbOPobj_addr.num = 0;
    }

  LINE(233);
    {
    gcbOPlook_index.num = 0;
    }

  LINE(234);
    {
    gcbOPlook_count.num = 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 init ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist2 *locals;
    Vlist17 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcbOPinit_actual;
static Vlist0 vals_gcbOPinit = {0, 0};
static siglist0 sigs_gcbOPinit = {0, 0};
static Vlist2 locals_gcbOPinit = {0, 2,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops}}
};
static Vlist0 popowns_gcbOPinit = {0, 0};
Slist0 tformals_gcbOPinit = {0, 0};
Slist0 opformals_gcbOPinit = {0, 0};
dbg_info_gcbOPinit_actual dbg_info_gcbOPinit_data = {0, 12, 
    "gcbOPinit", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcbOPinit, 0, 
    &vals_gcbOPinit, &sigs_gcbOPinit, &locals_gcbOPinit, &owns_gcb, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcbOPinit = (struct dbg_info*)&dbg_info_gcbOPinit_data;
extern struct dbg_info* dbg_info_gcbOPget_next_hdr;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcbOPget_next_hdr_TRACE
int gcbOPget_next_hdr_TRACE;
static int gcbOPget_next_hdr_own_init = 0;

/**** BEGIN PROCEDURE get_next_hdr ****/

errcode gcbOPget_next_hdr(ch, ret_1, ret_2)
CLUREF ch;
CLUREF *ret_1;
CLUREF *ret_2;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF this_addr;
        CLUREF hdr;
        CLUREF ch;
        } locals;
    locals.this_addr.num = UNINIT;
    locals.hdr.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcbOPget_next_hdr;
    locals.ch = ch;
        if (gcbOPget_next_hdr_own_init == 0) {
        if (gcb_own_init == 0) {
            locals.err = gcb_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcbOPget_next_hdr_own_init = 1;
    }
    enter_proc(237);

  LINE(239);
    {
        {locals.this_addr.num = gcbOPobj_addr.num;
        }
        }

  LINE(240);
    {
        {CLUREF T_2_1;
        locals.err = gcbOPgeti(locals.ch, &T_2_1);
        if (locals.err != ERR_ok) goto ex_1;
        locals.hdr.num = T_2_1.num;
        }
        }
        goto end_1;
        ex_1:
            if ((locals.err == ERR_end_of_file)) {

  LINE(241);
                {
                {signal (ERR_none);}}
            }
            else {
                goto ex_0;
            }
        end_1:;

  LINE(242);
    {
    {
    ret_1->num = locals.hdr.num;
    }
    {
    ret_2->num = locals.this_addr.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 get_next_hdr ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist2 *vals;
    siglist1 *sigs;
    Vlist5 *locals;
    Vlist17 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcbOPget_next_hdr_actual;
static Vlist2 vals_gcbOPget_next_hdr = {0, 2, { {0, 2, "", &int_ops},  {0, 2, "", &int_ops}}
};
static sig_desc0 sig_gcbOPget_next_hdr_1 = {0, 3, "none", {0, 0
}};
static siglist1 sigs_gcbOPget_next_hdr = {0, 1, (sig_desc*)&sig_gcbOPget_next_hdr_1};
static Vlist5 locals_gcbOPget_next_hdr = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "this_addr", &int_ops},  {0, 2, "hdr", &int_ops},  {0, 2, "ch", &_chan_ops}}
};
static Vlist0 popowns_gcbOPget_next_hdr = {0, 0};
Slist0 tformals_gcbOPget_next_hdr = {0, 0};
Slist0 opformals_gcbOPget_next_hdr = {0, 0};
dbg_info_gcbOPget_next_hdr_actual dbg_info_gcbOPget_next_hdr_data = {0, 12, 
    "gcbOPget_next_hdr", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcbOPget_next_hdr, 1, 
    &vals_gcbOPget_next_hdr, &sigs_gcbOPget_next_hdr, &locals_gcbOPget_next_hdr, &owns_gcb, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcbOPget_next_hdr = (struct dbg_info*)&dbg_info_gcbOPget_next_hdr_data;
extern struct dbg_info* dbg_info_gcbOPget_size;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcbOPget_size_TRACE
int gcbOPget_size_TRACE;
static int gcbOPget_size_own_init = 0;

/**** BEGIN PROCEDURE get_size ****/

errcode gcbOPget_size(ch, ret_1)
CLUREF ch;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF size;
        CLUREF ch;
        } locals;
    locals.size.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcbOPget_size;
    locals.ch = ch;
        if (gcbOPget_size_own_init == 0) {
        if (gcb_own_init == 0) {
            locals.err = gcb_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcbOPget_size_own_init = 1;
    }
    enter_proc(245);

  LINE(246);
    {
        {CLUREF T_1_1;
        locals.err = gcbOPgeti(locals.ch, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.size.num = T_1_1.num;
        }
        }

  LINE(247);
    {
    {
    ret_1->num = locals.size.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 get_size ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist17 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcbOPget_size_actual;
static Vlist1 vals_gcbOPget_size = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_gcbOPget_size = {0, 0};
static Vlist4 locals_gcbOPget_size = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "size", &int_ops},  {0, 2, "ch", &_chan_ops}}
};
static Vlist0 popowns_gcbOPget_size = {0, 0};
Slist0 tformals_gcbOPget_size = {0, 0};
Slist0 opformals_gcbOPget_size = {0, 0};
dbg_info_gcbOPget_size_actual dbg_info_gcbOPget_size_data = {0, 12, 
    "gcbOPget_size", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcbOPget_size, 1, 
    &vals_gcbOPget_size, &sigs_gcbOPget_size, &locals_gcbOPget_size, &owns_gcb, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcbOPget_size = (struct dbg_info*)&dbg_info_gcbOPget_size_data;
extern struct dbg_info* dbg_info_gcbOPget_array_info;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcbOPget_array_info_TRACE
int gcbOPget_array_info_TRACE;
static int gcbOPget_array_info_own_init = 0;

/**** BEGIN PROCEDURE get_array_info ****/

errcode gcbOPget_array_info(ch, ret_1, ret_2, ret_3, ret_4)
CLUREF ch;
CLUREF *ret_1;
CLUREF *ret_2;
CLUREF *ret_3;
CLUREF *ret_4;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF size;
        CLUREF low;
        CLUREF start;
        CLUREF predict;
        CLUREF ch;
        } locals;
    locals.size.num = UNINIT;
    locals.low.num = UNINIT;
    locals.start.num = UNINIT;
    locals.predict.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcbOPget_array_info;
    locals.ch = ch;
        if (gcbOPget_array_info_own_init == 0) {
        if (gcb_own_init == 0) {
            locals.err = gcb_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcbOPget_array_info_own_init = 1;
    }
    enter_proc(250);

  LINE(251);
    {
        {CLUREF T_1_1;
        locals.err = gcbOPgeti(locals.ch, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.size.num = T_1_1.num;
        }
        }

  LINE(252);
    {
        {CLUREF T_1_1;
        locals.err = gcbOPgeti(locals.ch, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.low.num = T_1_1.num;
        }
        }

  LINE(253);
    {
        {CLUREF T_1_1;
        locals.err = gcbOPgeti(locals.ch, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.start.num = T_1_1.num;
        }
        }

  LINE(254);
    {
        {CLUREF T_1_1;
        locals.err = gcbOPgeti(locals.ch, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.predict.num = T_1_1.num;
        }
        }

  LINE(255);
    {
    {
    ret_1->num = locals.size.num;
    }
    {
    ret_2->num = locals.low.num;
    }
    {
    ret_3->num = locals.start.num;
    }
    {
    ret_4->num = locals.predict.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 get_array_info ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist4 *vals;
    siglist0 *sigs;
    Vlist7 *locals;
    Vlist17 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcbOPget_array_info_actual;
static Vlist4 vals_gcbOPget_array_info = {0, 4, { {0, 2, "", &int_ops},  {0, 2, "", &int_ops},  {0, 2, "", &int_ops},  {0, 2, "", &int_ops}}
};
static siglist0 sigs_gcbOPget_array_info = {0, 0};
static Vlist7 locals_gcbOPget_array_info = {0, 7,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "size", &int_ops},  {0, 2, "low", &int_ops},  {0, 2, "start", &int_ops},  {0, 2, "predict", &int_ops},  {0, 2, "ch", &_chan_ops}}
};
static Vlist0 popowns_gcbOPget_array_info = {0, 0};
Slist0 tformals_gcbOPget_array_info = {0, 0};
Slist0 opformals_gcbOPget_array_info = {0, 0};
dbg_info_gcbOPget_array_info_actual dbg_info_gcbOPget_array_info_data = {0, 12, 
    "gcbOPget_array_info", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcbOPget_array_info, 1, 
    &vals_gcbOPget_array_info, &sigs_gcbOPget_array_info, &locals_gcbOPget_array_info, &owns_gcb, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcbOPget_array_info = (struct dbg_info*)&dbg_info_gcbOPget_array_info_data;
extern struct dbg_info* dbg_info_gcbOPget_next_obj;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcbOPget_next_obj_TRACE
int gcbOPget_next_obj_TRACE;
static int gcbOPget_next_obj_own_init = 0;

/**** BEGIN PROCEDURE get_next_obj ****/

errcode gcbOPget_next_obj(ch, ret_1)
CLUREF ch;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ty;
        CLUREF val;
        CLUREF ch;
        } locals;
    locals.ty.num = UNINIT;
    locals.val.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcbOPget_next_obj;
    locals.ch = ch;
        if (gcbOPget_next_obj_own_init == 0) {
        if (gcb_own_init == 0) {
            locals.err = gcb_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcbOPget_next_obj_own_init = 1;
    }
    enter_proc(258);

  LINE(260);
    for (;;) {
        if (true != true) { break; }

  LINE(261);
        locals.ty.num = UNINIT;
        locals.val.num = UNINIT;

  LINE(262);
        {
        CLUREF T_3_1;
        locals.err = gcbOPgeti(locals.ch, &T_3_1);
        if (locals.err != ERR_ok) goto ex_1;
        locals.ty.num = T_3_1.num;
        }
            goto end_1;
            ex_1:
                if ((locals.err == ERR_end_of_file)) {

  LINE(263);
                    {
                    {signal (ERR_none);}}
                }
                else {
                    goto ex_0;
                }
            end_1:;

  LINE(264);
        {
        CLUREF T_3_1;
        locals.err = gcbOPgeti(locals.ch, &T_3_1);
        if (locals.err != ERR_ok) goto ex_2;
        locals.val.num = T_3_1.num;
        }
            goto end_2;
            ex_2:
                if ((locals.err == ERR_end_of_file)) {

  LINE(266);
                    {
                    elist[0] = STR_bad_040format_040file;
                    {signal (ERR_not_possible);}}
                }
                else {
                    goto ex_0;
                }
            end_2:;

  LINE(267);
        {
        CLUREF T_2_1;
        T_2_1.num = (locals.ty.num == 32)? true : false;
        if (T_2_1.num == true) {

  LINE(269);
            {
            {
            CLUREF T_3_1;
            T_3_1.num = locals.val.num;
            ret_1->num = T_3_1.num;
            }
            {signal (ERR_ok);}}
            }
        else {
        CLUREF T_2_2;
        T_2_2.num = (locals.ty.num == 33)? true : false;
        if (T_2_2.num == true) {

  LINE(272);
            {
            {
            CLUREF T_3_1;
            locals.err = gcoOPget_obj(locals.val, &T_3_1);
            if (locals.err != ERR_ok) goto ex_0;
            ret_1->num = T_3_1.num;
            }
            {signal (ERR_ok);}}
            }
        else {

  LINE(274);
            {
            elist[0] = STR_bad_040format_040file;
            {signal (ERR_not_possible);}}
            }}}/* end if */
        }
        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: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE get_next_obj ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist2 *sigs;
    Vlist5 *locals;
    Vlist17 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcbOPget_next_obj_actual;
static Vlist1 vals_gcbOPget_next_obj = {0, 1, { {0, 2, "", &_obj_ops}}
};
static sig_desc0 sig_gcbOPget_next_obj_1 = {0, 3, "none", {0, 0
}};
static sig_desc1 sig_gcbOPget_next_obj_2 = {0, 4, "not_possible", {0, 1
, { {0, 2, "", &string_ops}}}};
static siglist2 sigs_gcbOPget_next_obj = {0, 2, (sig_desc*)&sig_gcbOPget_next_obj_1, (sig_desc*)&sig_gcbOPget_next_obj_2};
static Vlist5 locals_gcbOPget_next_obj = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ty", &int_ops},  {0, 2, "val", &int_ops},  {0, 2, "ch", &_chan_ops}}
};
static Vlist0 popowns_gcbOPget_next_obj = {0, 0};
Slist0 tformals_gcbOPget_next_obj = {0, 0};
Slist0 opformals_gcbOPget_next_obj = {0, 0};
dbg_info_gcbOPget_next_obj_actual dbg_info_gcbOPget_next_obj_data = {0, 12, 
    "gcbOPget_next_obj", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcbOPget_next_obj, 1, 
    &vals_gcbOPget_next_obj, &sigs_gcbOPget_next_obj, &locals_gcbOPget_next_obj, &owns_gcb, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcbOPget_next_obj = (struct dbg_info*)&dbg_info_gcbOPget_next_obj_data;
extern struct dbg_info* dbg_info_gcbOPskip_obj;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcbOPskip_obj_TRACE
int gcbOPskip_obj_TRACE;
extern errcode gcbOPskip_obj_IB_1();
static int gcbOPskip_obj_own_init = 0;

/**** BEGIN PROCEDURE skip_obj ****/

errcode gcbOPskip_obj(ch, count)
CLUREF ch;
CLUREF count;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF i;
        CLUREF ty;
        CLUREF val;
        CLUREF ch;
        CLUREF count;
        } locals;
    locals.i.num = UNINIT;
    locals.ty.num = UNINIT;
    locals.val.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.count.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcbOPskip_obj;
    locals.ch = ch;
    locals.count = count;
        if (gcbOPskip_obj_own_init == 0) {
        if (gcb_own_init == 0) {
            locals.err = gcb_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcbOPskip_obj_own_init = 1;
    }
    enter_proc(279);

  LINE(280);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals.count.num == 0)? true : false;
    if (T_1_1.num == true) {
        {
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(281);
    {
        locals.err = intOPfrom_to(CLU_1, locals.count, gcbOPskip_obj_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 skip_obj ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist2 *sigs;
    Vlist7 *locals;
    Vlist17 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcbOPskip_obj_actual;
static Vlist0 vals_gcbOPskip_obj = {0, 0};
static sig_desc0 sig_gcbOPskip_obj_1 = {0, 3, "none", {0, 0
}};
static sig_desc1 sig_gcbOPskip_obj_2 = {0, 4, "not_possible", {0, 1
, { {0, 2, "", &string_ops}}}};
static siglist2 sigs_gcbOPskip_obj = {0, 2, (sig_desc*)&sig_gcbOPskip_obj_1, (sig_desc*)&sig_gcbOPskip_obj_2};
static Vlist7 locals_gcbOPskip_obj = {0, 7,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "i", &int_ops},  {0, 2, "ty", &int_ops},  {0, 2, "val", &int_ops},  {0, 2, "ch", &_chan_ops},  {0, 2, "count", &int_ops}}
};
static Vlist0 popowns_gcbOPskip_obj = {0, 0};
Slist0 tformals_gcbOPskip_obj = {0, 0};
Slist0 opformals_gcbOPskip_obj = {0, 0};
dbg_info_gcbOPskip_obj_actual dbg_info_gcbOPskip_obj_data = {0, 12, 
    "gcbOPskip_obj", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcbOPskip_obj, 2, 
    &vals_gcbOPskip_obj, &sigs_gcbOPskip_obj, &locals_gcbOPskip_obj, &owns_gcb, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcbOPskip_obj = (struct dbg_info*)&dbg_info_gcbOPskip_obj_data;

/**** BEGIN ITERATOR BODIES for skip_obj ****/

errcode gcbOPskip_obj_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    struct dbg_info *DBG_INFO;
    int DBG_LINE;
    errcode err;
    errcode ecode2;
    CLUREF i;
    CLUREF ty;
    CLUREF val;
    CLUREF ch;
    CLUREF count;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(283);

  FB_LINE(282);
    {
        {CLUREF T_2_1;
        locals->err = gcbOPgeti(locals->ch, &T_2_1);
        if (locals->err != ERR_ok) goto ex_1;
        locals->ty.num = T_2_1.num;
        }
        }
        goto end_1;
        ex_1:
            if ((locals->err == ERR_end_of_file)) {

  FB_LINE(283);
                {
                *iecode = ERR_none;
                {signal(ERR_iterbodysignal);}
                }
            }
            else {
                goto ex_0;
            }
        end_1:;

  FB_LINE(284);
    {
        {CLUREF T_2_1;
        locals->err = gcbOPgeti(locals->ch, &T_2_1);
        if (locals->err != ERR_ok) goto ex_2;
        locals->val.num = T_2_1.num;
        }
        }
        goto end_2;
        ex_2:
            if ((locals->err == ERR_end_of_file)) {

  FB_LINE(286);
                {
                elist[0] = STR_bad_040format_040file;
                *iecode = ERR_not_possible;
                {signal(ERR_iterbodysignal);}
                }
            }
            else {
                goto ex_0;
            }
        end_2:;

  FB_LINE(287);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    CLUREF T_1_5;
    T_1_2.num = (locals->ty.num == 32)? true : false;
    T_1_3.num = T_1_2.num ^ 1;
    T_1_1.num = T_1_3.num;
    if (T_1_3.num) {
        T_1_4.num = (locals->ty.num == 33)? true : false;
        T_1_5.num = T_1_4.num ^ 1;
        T_1_1.num = T_1_5.num;
    }
    if (T_1_1.num == true) {

  FB_LINE(289);
        {
        elist[0] = STR_bad_040format_040file;
        *iecode = ERR_not_possible;
        {signal(ERR_iterbodysignal);}
        }
        }
        }/* end if */
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end gcbOPskip_obj_IB_1 */

/**** END ITERATOR BODIES for skip_obj ****/

extern struct dbg_info* dbg_info_gcbOPgeti;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcbOPgeti_TRACE
int gcbOPgeti_TRACE;
static int gcbOPgeti_own_init = 0;

/**** BEGIN PROCEDURE geti ****/

errcode gcbOPgeti(ch, ret_1)
CLUREF ch;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ans;
        CLUREF ch;
        } locals;
    locals.ans.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcbOPgeti;
    locals.ch = ch;
        if (gcbOPgeti_own_init == 0) {
        if (gcb_own_init == 0) {
            locals.err = gcb_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcbOPgeti_own_init = 1;
    }
    enter_proc(294);

  LINE(296);
    {
    CLUREF T_1_1;
    T_1_1.num = (gcbOPlook_count.num == 0)? true : false;
    if (T_1_1.num == true) {

  LINE(297);
        {
        CLUREF T_3_1;
        locals.err = _chanOPgetw(locals.ch, gcbOPlookahead, &T_3_1);
        if (locals.err != ERR_ok) goto ex_1;
        gcbOPlook_count.num = T_3_1.num;
        }
        goto end_1;
        ex_1:
            if (locals.err == ERR_end_of_file) {signal(ERR_end_of_file);}
            else {
                goto ex_0;}
        end_1:;

  LINE(299);
        {
        gcbOPlook_index.num = 1;
        }
        }
        }/* end if */

  LINE(301);
    {
        {CLUREF T_1_1;
        locals.err = _wordvecOPfetch(gcbOPlookahead, gcbOPlook_index, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.ans.num = T_1_1.num;
        }
        }

  LINE(302);
    {
    CLUREF T_1_1;
    locals.err = intOPsub(gcbOPlook_count, CLU_4, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    gcbOPlook_count.num = T_1_1.num;
    }

  LINE(303);
    {
    CLUREF T_1_1;
    locals.err = intOPadd(gcbOPlook_index, CLU_1, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    gcbOPlook_index.num = T_1_1.num;
    }

  LINE(304);
    {
    CLUREF T_1_1;
    locals.err = intOPadd(gcbOPobj_addr, CLU_4, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    gcbOPobj_addr.num = T_1_1.num;
    }

  LINE(305);
    {
    {
    ret_1->num = locals.ans.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 geti ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist2 *sigs;
    Vlist4 *locals;
    Vlist17 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcbOPgeti_actual;
static Vlist1 vals_gcbOPgeti = {0, 1, { {0, 2, "", &int_ops}}
};
static sig_desc0 sig_gcbOPgeti_1 = {0, 3, "end_of_file", {0, 0
}};
static sig_desc1 sig_gcbOPgeti_2 = {0, 4, "not_possible", {0, 1
, { {0, 2, "", &string_ops}}}};
static siglist2 sigs_gcbOPgeti = {0, 2, (sig_desc*)&sig_gcbOPgeti_1, (sig_desc*)&sig_gcbOPgeti_2};
static Vlist4 locals_gcbOPgeti = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ans", &int_ops},  {0, 2, "ch", &_chan_ops}}
};
static Vlist0 popowns_gcbOPgeti = {0, 0};
Slist0 tformals_gcbOPgeti = {0, 0};
Slist0 opformals_gcbOPgeti = {0, 0};
dbg_info_gcbOPgeti_actual dbg_info_gcbOPgeti_data = {0, 12, 
    "gcbOPgeti", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcbOPgeti, 1, 
    &vals_gcbOPgeti, &sigs_gcbOPgeti, &locals_gcbOPgeti, &owns_gcb, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcbOPgeti = (struct dbg_info*)&dbg_info_gcbOPgeti_data;
extern struct dbg_info* dbg_info_gcbOPgetb;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcbOPgetb_TRACE
int gcbOPgetb_TRACE;
extern OWN_req _bytevec_ownreqs;
static int gcbOPgetb_own_init = 0;

/**** BEGIN PROCEDURE getb ****/

errcode gcbOPgetb(ch, b)
CLUREF ch;
CLUREF b;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF copied;
        CLUREF data_count;
        CLUREF pad_count;
        CLUREF b_index;
        CLUREF count;
        CLUREF ch;
        CLUREF b;
        } locals;
    locals.copied.num = UNINIT;
    locals.data_count.num = UNINIT;
    locals.pad_count.num = UNINIT;
    locals.b_index.num = UNINIT;
    locals.count.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.b.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcbOPgetb;
    locals.ch = ch;
    locals.b = b;
        if (gcbOPgetb_own_init == 0) {
        if (gcb_own_init == 0) {
            locals.err = gcb_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcbOPgetb_own_init = 1;
    }
    enter_proc(308);

  LINE(310);
    {
        {locals.copied.num = 0;
        }
        }

  LINE(311);
    {
        {CLUREF T_1_1;
        locals.err = _bytevecOPsize(locals.b, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.data_count.num = T_1_1.num;
        }
        }

  LINE(312);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        locals.err = intOPadd(locals.data_count, CLU_4, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPdiv(T_1_1, CLU_4, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPmul(T_1_2, CLU_4, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPsub(T_1_3, locals.data_count, &T_1_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.pad_count.num = T_1_4.num;
        }
        }

  LINE(313);
    {
        {locals.b_index.num = 1;
        }
        }

  LINE(314);
    for (;;) {
        CLUREF T_1_1;
        T_1_1.num = (locals.copied.num < locals.data_count.num)? true : false;
        if (T_1_1.num != true) { break; }

  LINE(315);
        {
        CLUREF T_2_1;
        T_2_1.num = (gcbOPlook_count.num == 0)? true : false;
        if (T_2_1.num == true) {

  LINE(316);
            {
            CLUREF T_4_1;
            locals.err = _chanOPgetw(locals.ch, gcbOPlookahead, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            gcbOPlook_count.num = T_4_1.num;
            }
            goto end_1;
            ex_1:
                if (locals.err == ERR_end_of_file) {signal(ERR_end_of_file);}
                else {
                    goto ex_0;}
            end_1:;

  LINE(318);
            {
            gcbOPlook_index.num = 1;
            }
            }
            }/* end if */

  LINE(320);
        {
            {CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            locals.err = intOPsub(locals.data_count, locals.b_index, &T_2_1);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = intOPadd(T_2_1, CLU_1, &T_2_2);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = intOPmin(T_2_2, gcbOPlook_count, &T_2_3);
            if (locals.err != ERR_ok) goto ex_0;
            locals.count.num = T_2_3.num;
            }
            }

  LINE(321);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        locals.err = intOPsub(gcbOPlook_index, CLU_1, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPmul(T_2_1, CLU_4, &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.err = _wordvecOPmove_w2b(gcbOPlookahead, T_2_3, locals.b, locals.b_index, locals.count);
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(322);
        {
        CLUREF T_2_1;
        locals.err = intOPsub(gcbOPlook_count, locals.count, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        gcbOPlook_count.num = T_2_1.num;
        }

  LINE(323);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        locals.err = intOPdiv(locals.count, CLU_4, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPadd(gcbOPlook_index, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        gcbOPlook_index.num = T_2_2.num;
        }

  LINE(324);
        {
        CLUREF T_2_1;
        locals.err = intOPadd(locals.b_index, locals.count, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.b_index.num = T_2_1.num;
        }

  LINE(325);
        {
        CLUREF T_2_1;
        locals.err = intOPadd(locals.copied, locals.count, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.copied.num = T_2_1.num;
        }
        }
        end_while_1:;

  LINE(327);
    {
    CLUREF T_1_1;
    T_1_1.num = (gcbOPlook_count.num == 0)? true : false;
    if (T_1_1.num == true) {

  LINE(328);
        {
        CLUREF T_3_1;
        locals.err = _chanOPgetw(locals.ch, gcbOPlookahead, &T_3_1);
        if (locals.err != ERR_ok) goto ex_2;
        gcbOPlook_count.num = T_3_1.num;
        }
        goto end_2;
        ex_2:
            if (locals.err == ERR_end_of_file) {signal(ERR_end_of_file);}
            else {
                goto ex_0;}
        end_2:;

  LINE(330);
        {
        gcbOPlook_index.num = 1;
        }
        }
        }/* end if */

  LINE(332);
    {
    CLUREF T_1_1;
    locals.err = intOPsub(gcbOPlook_count, locals.pad_count, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    gcbOPlook_count.num = T_1_1.num;
    }

  LINE(333);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = (locals.pad_count.num == 0)? true : false;
    T_1_2.num = T_1_1.num ^ 1;
    if (T_1_2.num == true) {
        {
        CLUREF T_2_1;
        locals.err = intOPadd(gcbOPlook_index, CLU_1, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        gcbOPlook_index.num = T_2_1.num;
        }
        }
        }/* end if */

  LINE(334);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    locals.err = intOPadd(gcbOPobj_addr, locals.data_count, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = intOPadd(T_1_1, locals.pad_count, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    gcbOPobj_addr.num = T_1_2.num;
    }
    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 getb ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist2 *sigs;
    Vlist9 *locals;
    Vlist17 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcbOPgetb_actual;
static Vlist0 vals_gcbOPgetb = {0, 0};
static sig_desc0 sig_gcbOPgetb_1 = {0, 3, "end_of_file", {0, 0
}};
static sig_desc1 sig_gcbOPgetb_2 = {0, 4, "not_possible", {0, 1
, { {0, 2, "", &string_ops}}}};
static siglist2 sigs_gcbOPgetb = {0, 2, (sig_desc*)&sig_gcbOPgetb_1, (sig_desc*)&sig_gcbOPgetb_2};
static Vlist9 locals_gcbOPgetb = {0, 9,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "copied", &int_ops},  {0, 2, "data_count", &int_ops},  {0, 2, "pad_count", &int_ops},  {0, 2, "b_index", &int_ops},  {0, 2, "count", &int_ops},  {0, 2, "ch", &_chan_ops},  {0, 2, "b", &_bytevec_ops}}
};
static Vlist0 popowns_gcbOPgetb = {0, 0};
Slist0 tformals_gcbOPgetb = {0, 0};
Slist0 opformals_gcbOPgetb = {0, 0};
dbg_info_gcbOPgetb_actual dbg_info_gcbOPgetb_data = {0, 12, 
    "gcbOPgetb", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcbOPgetb, 2, 
    &vals_gcbOPgetb, &sigs_gcbOPgetb, &locals_gcbOPgetb, &owns_gcb, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcbOPgetb = (struct dbg_info*)&dbg_info_gcbOPgetb_data;
extern struct dbg_info* dbg_info_gcbOPskip;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcbOPskip_TRACE
int gcbOPskip_TRACE;
static int gcbOPskip_own_init = 0;

/**** BEGIN PROCEDURE skip ****/

errcode gcbOPskip(ch, i)
CLUREF ch;
CLUREF i;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF i4;
        CLUREF skipped;
        CLUREF count;
        CLUREF ch;
        CLUREF i;
        } locals;
    locals.i4.num = UNINIT;
    locals.skipped.num = UNINIT;
    locals.count.num = UNINIT;
    locals.ch.num = UNINIT;
    locals.i.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcbOPskip;
    locals.ch = ch;
    locals.i = i;
        if (gcbOPskip_own_init == 0) {
        if (gcb_own_init == 0) {
            locals.err = gcb_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcbOPskip_own_init = 1;
    }
    enter_proc(337);

  LINE(339);
    {
        {CLUREF T_1_1;
        locals.err = intOPmul(locals.i, CLU_4, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.i4.num = T_1_1.num;
        }
        }

  LINE(340);
    {
        {locals.skipped.num = 0;
        }
        }

  LINE(341);
    for (;;) {
        CLUREF T_1_1;
        T_1_1.num = (locals.skipped.num < locals.i4.num)? true : false;
        if (T_1_1.num != true) { break; }

  LINE(342);
        {
        CLUREF T_2_1;
        T_2_1.num = (gcbOPlook_count.num == 0)? true : false;
        if (T_2_1.num == true) {

  LINE(343);
            {
            CLUREF T_4_1;
            locals.err = _chanOPgetw(locals.ch, gcbOPlookahead, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            gcbOPlook_count.num = T_4_1.num;
            }
            goto end_1;
            ex_1:
                if (locals.err == ERR_end_of_file) {signal(ERR_end_of_file);}
                else {
                    goto ex_0;}
            end_1:;

  LINE(345);
            {
            gcbOPlook_index.num = 1;
            }
            }
            }/* end if */

  LINE(347);
        {
            {CLUREF T_2_1;
            CLUREF T_2_2;
            locals.err = intOPsub(locals.i4, locals.skipped, &T_2_1);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = intOPmin(T_2_1, gcbOPlook_count, &T_2_2);
            if (locals.err != ERR_ok) goto ex_0;
            locals.count.num = T_2_2.num;
            }
            }

  LINE(348);
        {
        CLUREF T_2_1;
        locals.err = intOPsub(gcbOPlook_count, locals.count, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        gcbOPlook_count.num = T_2_1.num;
        }

  LINE(349);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        locals.err = intOPdiv(locals.count, CLU_4, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPadd(gcbOPlook_index, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        gcbOPlook_index.num = T_2_2.num;
        }

  LINE(350);
        {
        CLUREF T_2_1;
        locals.err = intOPadd(locals.skipped, locals.count, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.skipped.num = T_2_1.num;
        }
        }
        end_while_1:;

  LINE(352);
    {
    CLUREF T_1_1;
    locals.err = intOPadd(gcbOPobj_addr, locals.i4, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    gcbOPobj_addr.num = T_1_1.num;
    }
    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 skip ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist2 *sigs;
    Vlist7 *locals;
    Vlist17 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcbOPskip_actual;
static Vlist0 vals_gcbOPskip = {0, 0};
static sig_desc0 sig_gcbOPskip_1 = {0, 3, "end_of_file", {0, 0
}};
static sig_desc1 sig_gcbOPskip_2 = {0, 4, "not_possible", {0, 1
, { {0, 2, "", &string_ops}}}};
static siglist2 sigs_gcbOPskip = {0, 2, (sig_desc*)&sig_gcbOPskip_1, (sig_desc*)&sig_gcbOPskip_2};
static Vlist7 locals_gcbOPskip = {0, 7,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "i4", &int_ops},  {0, 2, "skipped", &int_ops},  {0, 2, "count", &int_ops},  {0, 2, "ch", &_chan_ops},  {0, 2, "i", &int_ops}}
};
static Vlist0 popowns_gcbOPskip = {0, 0};
Slist0 tformals_gcbOPskip = {0, 0};
Slist0 opformals_gcbOPskip = {0, 0};
dbg_info_gcbOPskip_actual dbg_info_gcbOPskip_data = {0, 12, 
    "gcbOPskip", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcbOPskip, 2, 
    &vals_gcbOPskip, &sigs_gcbOPskip, &locals_gcbOPskip, &owns_gcb, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcbOPskip = (struct dbg_info*)&dbg_info_gcbOPskip_data;
extern struct dbg_info* dbg_info_gcbOPdebug_print;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcbOPdebug_print_TRACE
int gcbOPdebug_print_TRACE;
static int gcbOPdebug_print_own_init = 0;

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

errcode gcbOPdebug_print(_rep, ps)
CLUREF _rep;
CLUREF ps;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF _rep;
        CLUREF ps;
        } locals;
    locals._rep.num = UNINIT;
    locals.ps.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcbOPdebug_print;
    locals._rep = _rep;
    locals.ps = ps;
        if (gcbOPdebug_print_own_init == 0) {
        if (gcb_own_init == 0) {
            locals.err = gcb_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcbOPdebug_print_own_init = 1;
    }
    enter_proc(1);

  LINE(2);
    {
    locals.err = nullOPdebug_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 ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist17 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcbOPdebug_print_actual;
static Vlist0 vals_gcbOPdebug_print = {0, 0};
static siglist0 sigs_gcbOPdebug_print = {0, 0};
static Vlist4 locals_gcbOPdebug_print = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "_rep", &null_ops},  {0, 2, "ps", &pstream_ops}}
};
static Vlist0 popowns_gcbOPdebug_print = {0, 0};
Slist0 tformals_gcbOPdebug_print = {0, 0};
Slist0 opformals_gcbOPdebug_print = {0, 0};
dbg_info_gcbOPdebug_print_actual dbg_info_gcbOPdebug_print_data = {0, 12, 
    "gcbOPdebug_print", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcbOPdebug_print, 2, 
    &vals_gcbOPdebug_print, &sigs_gcbOPdebug_print, &locals_gcbOPdebug_print, &owns_gcb, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcbOPdebug_print = (struct dbg_info*)&dbg_info_gcbOPdebug_print_data;
typedef struct{
    int count;
    OWNPTR type_owns;
    OWNPTR op_owns;
    struct OP_ENTRY entry[10];
} gcb_OPS;

CLU_proc gcb_oe_get_array_info = {{0,0,0,0}, gcbOPget_array_info, 0};
CLU_proc gcb_oe_get_next_hdr = {{0,0,0,0}, gcbOPget_next_hdr, 0};
CLU_proc gcb_oe_get_next_obj = {{0,0,0,0}, gcbOPget_next_obj, 0};
CLU_proc gcb_oe_get_size = {{0,0,0,0}, gcbOPget_size, 0};
CLU_proc gcb_oe_getb = {{0,0,0,0}, gcbOPgetb, 0};
CLU_proc gcb_oe_geti = {{0,0,0,0}, gcbOPgeti, 0};
CLU_proc gcb_oe_init = {{0,0,0,0}, gcbOPinit, 0};
CLU_proc gcb_oe_skip = {{0,0,0,0}, gcbOPskip, 0};
CLU_proc gcb_oe_skip_obj = {{0,0,0,0}, gcbOPskip_obj, 0};
CLU_proc gcb_oe_debug_print = {{0,0,0,0}, gcbOPdebug_print, 0};

gcb_OPS gcb_ops_actual = {10, (OWNPTR)&gcb_own_init, (OWNPTR)&gcb_own_init, {
    {&gcb_oe_get_array_info, "get_array_info"},
    {&gcb_oe_get_next_hdr, "get_next_hdr"},
    {&gcb_oe_get_next_obj, "get_next_obj"},
    {&gcb_oe_get_size, "get_size"},
    {&gcb_oe_getb, "getb"},
    {&gcb_oe_geti, "geti"},
    {&gcb_oe_init, "init"},
    {&gcb_oe_skip, "skip"},
    {&gcb_oe_skip_obj, "skip_obj"},
    {&gcb_oe_debug_print, "debug_print"}}};

struct OPS *gcb_ops = (struct OPS *)&gcb_ops_actual;

/**** END CLUSTER gcb ****/

/**** BEGIN CLUSTER gco ****/

extern errcode arrayOPfill();
extern errcode hash_int();
extern errcode arrayOPfetch();
extern errcode _objOPequal();
extern errcode recordOPget_1();
extern errcode recordOPget_2();
extern errcode recordOPget_3();
extern errcode arrayOPstore();
extern errcode arrayOPnew();
struct OPS  *record_key_next_val_ops;
extern struct OPS *record_key_next_val_ops;
struct OPS *array_of_record_key_next_val_table;
struct OPS *array_of_record_key_next_val_ops;
struct OPS *array_of_record_key_next_val_ops;
OWNPTR array_of_record_key_next_val_owns;
static int gco_own_init = 0;
OWN_req gco_ownreqs = {0,0};
CLUREF gcoOPobj_store;
errcode gco_own_init_proc()
{
struct {
    errcode err;
    } locals;
    enter_own_init_proc();
        if (gco_own_init == 0) {
        add_selector_info("key", 0, int_ops); 
        add_selector_info("next", 1, _obj_ops); 
        add_selector_info("val", 2, _obj_ops); 
        find_selector_ops("record", 3, &(record_key_next_val_ops));
        add_parm_info_type(0, record_key_next_val_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(array_of_record_key_next_val_ops));
        gco_own_init = 1;
        gcoOPobj_store.num = UNINIT;
        {signal(ERR_ok);}
    ex_0: pclu_unhandled(locals.err); {signal(ERR_failure);}
        }
    }

extern struct dbg_info* dbg_info_gcoOPinit;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcoOPinit_TRACE
int gcoOPinit_TRACE;
extern struct OPS *array_of_record_key_next_val_ops;
static Vlist7 owns_gco = {0, 7,{ {0, 2, "gco_init", &int_ops}
,  {0, 2, "obj_store", &array_of_record_key_next_val_ops}, {0, 2, "gcoOPinit_init", &int_ops}
, {0, 2, "gcoOPinit_init", &int_ops}
, {0, 2, "gcoOPinit_init", &int_ops}
, {0, 2, "gcoOPinit_init", &int_ops}
, {0, 2, "gcoOPinit_init", &int_ops}
}
};
struct OPS  *record_key_next_val_ops;
struct OPS *array_of_record_key_next_val_table;
struct OPS *array_of_record_key_next_val_ops;
struct OPS *array_of_record_key_next_val_ops;
OWNPTR array_of_record_key_next_val_owns;
static int gcoOPinit_own_init = 0;

/**** BEGIN PROCEDURE init ****/

errcode gcoOPinit()
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF no_bucket;
        } locals;
    locals.no_bucket.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcoOPinit;
        if (gcoOPinit_own_init == 0) {
        if (gco_own_init == 0) {
            locals.err = gco_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcoOPinit_own_init = 1;
    }
    enter_proc(368);

  LINE(369);
    {
        {CLUREF T_1_1;
        T_1_1.num = nil;
        locals.no_bucket.num = T_1_1.num;
        }
        }

  LINE(370);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = 50000;
    locals.err = arrayOPfill(CLU_1, T_1_1, locals.no_bucket, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    gcoOPobj_store.num = T_1_2.num;
    }
    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 init ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist3 *locals;
    Vlist7 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcoOPinit_actual;
static Vlist0 vals_gcoOPinit = {0, 0};
static siglist0 sigs_gcoOPinit = {0, 0};
static Vlist3 locals_gcoOPinit = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "no_bucket", &record_key_next_val_ops}}
};
static Vlist0 popowns_gcoOPinit = {0, 0};
Slist0 tformals_gcoOPinit = {0, 0};
Slist0 opformals_gcoOPinit = {0, 0};
dbg_info_gcoOPinit_actual dbg_info_gcoOPinit_data = {0, 12, 
    "gcoOPinit", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcoOPinit, 0, 
    &vals_gcoOPinit, &sigs_gcoOPinit, &locals_gcoOPinit, &owns_gco, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcoOPinit = (struct dbg_info*)&dbg_info_gcoOPinit_data;
extern struct dbg_info* dbg_info_gcoOPget_obj;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcoOPget_obj_TRACE
int gcoOPget_obj_TRACE;
struct OPS  *record_key_next_val_ops;
struct OPS *array_of_record_key_next_val_table;
struct OPS *array_of_record_key_next_val_ops;
struct OPS *array_of_record_key_next_val_ops;
OWNPTR array_of_record_key_next_val_owns;
static int gcoOPget_obj_own_init = 0;

/**** BEGIN PROCEDURE get_obj ****/

errcode gcoOPget_obj(i, ret_1)
CLUREF i;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF k;
        CLUREF this_buck;
        CLUREF i;
        } locals;
    locals.k.num = UNINIT;
    locals.this_buck.num = UNINIT;
    locals.i.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcoOPget_obj;
    locals.i = i;
        if (gcoOPget_obj_own_init == 0) {
        if (gco_own_init == 0) {
            locals.err = gco_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcoOPget_obj_own_init = 1;
    }
    enter_proc(373);

  LINE(375);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = 50000;
        locals.err = hash_int(locals.i, T_1_1, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPadd(T_1_2, CLU_1, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.k.num = T_1_3.num;
        }
        }

  LINE(376);
    {
        {CLUREF T_1_1;
        locals.err = arrayOPfetch(gcoOPobj_store, locals.k, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.this_buck.num = T_1_1.num;
        }
        }

  LINE(377);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        CLUREF T_1_5;
        CLUREF T_1_6;
        CLUREF T_1_7;
        CLUREF T_1_8;
        T_1_2.num = locals.this_buck.num;
        T_1_3.num = nil;
        T_1_4.num = (T_1_2.num == T_1_3.num)? true : false;
        T_1_5.num = T_1_4.num ^ 1;
        T_1_1.num = T_1_5.num;
        if (T_1_5.num) {
            T_1_6.num = locals.this_buck.vec->data[0];
            T_1_7.num = (T_1_6.num == locals.i.num)? true : false;
            T_1_8.num = T_1_7.num ^ 1;
            T_1_1.num = T_1_8.num;
        }
        if (T_1_1.num != true) { break; }

  LINE(378);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.this_buck.vec->data[1];
        T_2_2.num = T_2_1.num;
        locals.this_buck.num = T_2_2.num;
        }
        }
        end_while_1:;

  LINE(380);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    T_1_1.num = locals.this_buck.num;
    T_1_2.num = nil;
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    if (T_1_3.num == true) {
        {
        {signal (ERR_not_found);}}
        }
        }/* end if */

  LINE(381);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.this_buck.vec->data[2];
    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 get_obj ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist5 *locals;
    Vlist7 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcoOPget_obj_actual;
static Vlist1 vals_gcoOPget_obj = {0, 1, { {0, 2, "", &_obj_ops}}
};
static sig_desc0 sig_gcoOPget_obj_1 = {0, 3, "not_found", {0, 0
}};
static siglist1 sigs_gcoOPget_obj = {0, 1, (sig_desc*)&sig_gcoOPget_obj_1};
static Vlist5 locals_gcoOPget_obj = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "k", &int_ops},  {0, 2, "this_buck", &record_key_next_val_ops},  {0, 2, "i", &int_ops}}
};
static Vlist0 popowns_gcoOPget_obj = {0, 0};
Slist0 tformals_gcoOPget_obj = {0, 0};
Slist0 opformals_gcoOPget_obj = {0, 0};
dbg_info_gcoOPget_obj_actual dbg_info_gcoOPget_obj_data = {0, 12, 
    "gcoOPget_obj", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcoOPget_obj, 1, 
    &vals_gcoOPget_obj, &sigs_gcoOPget_obj, &locals_gcoOPget_obj, &owns_gco, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcoOPget_obj = (struct dbg_info*)&dbg_info_gcoOPget_obj_data;
extern struct dbg_info* dbg_info_gcoOPsave_new_obj;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcoOPsave_new_obj_TRACE
int gcoOPsave_new_obj_TRACE;
struct OPS  *record_key_next_val_ops;
struct OPS *array_of_record_key_next_val_table;
struct OPS *array_of_record_key_next_val_ops;
struct OPS *array_of_record_key_next_val_ops;
OWNPTR array_of_record_key_next_val_owns;
static int gcoOPsave_new_obj_own_init = 0;

/**** BEGIN PROCEDURE save_new_obj ****/

errcode gcoOPsave_new_obj(i, o)
CLUREF i;
CLUREF o;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF k;
        CLUREF this_buck;
        CLUREF i;
        CLUREF o;
        } locals;
    locals.k.num = UNINIT;
    locals.this_buck.num = UNINIT;
    locals.i.num = UNINIT;
    locals.o.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcoOPsave_new_obj;
    locals.i = i;
    locals.o = o;
        if (gcoOPsave_new_obj_own_init == 0) {
        if (gco_own_init == 0) {
            locals.err = gco_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcoOPsave_new_obj_own_init = 1;
    }
    enter_proc(384);

  LINE(385);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = 50000;
        locals.err = hash_int(locals.i, T_1_1, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPadd(T_1_2, CLU_1, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.k.num = T_1_3.num;
        }
        }

  LINE(386);
    {
        {CLUREF T_1_1;
        locals.err = arrayOPfetch(gcoOPobj_store, locals.k, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.this_buck.num = T_1_1.num;
        }
        }

  LINE(387);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    RecordAlloc(3, T_1_1);
    T_1_1.vec->data[0]  = locals.i.num;
    T_1_1.vec->data[2]  = locals.o.num;
    T_1_2.num = locals.this_buck.num;
    T_1_1.vec->data[1]  = T_1_2.num;
    locals.err = arrayOPstore(gcoOPobj_store, locals.k, T_1_1);
    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 save_new_obj ****/

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;
    Vlist7 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcoOPsave_new_obj_actual;
static Vlist0 vals_gcoOPsave_new_obj = {0, 0};
static siglist0 sigs_gcoOPsave_new_obj = {0, 0};
static Vlist6 locals_gcoOPsave_new_obj = {0, 6,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "k", &int_ops},  {0, 2, "this_buck", &record_key_next_val_ops},  {0, 2, "i", &int_ops},  {0, 2, "o", &_obj_ops}}
};
static Vlist0 popowns_gcoOPsave_new_obj = {0, 0};
Slist0 tformals_gcoOPsave_new_obj = {0, 0};
Slist0 opformals_gcoOPsave_new_obj = {0, 0};
dbg_info_gcoOPsave_new_obj_actual dbg_info_gcoOPsave_new_obj_data = {0, 12, 
    "gcoOPsave_new_obj", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcoOPsave_new_obj, 2, 
    &vals_gcoOPsave_new_obj, &sigs_gcoOPsave_new_obj, &locals_gcoOPsave_new_obj, &owns_gco, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcoOPsave_new_obj = (struct dbg_info*)&dbg_info_gcoOPsave_new_obj_data;
extern struct dbg_info* dbg_info_gcoOPreset;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcoOPreset_TRACE
int gcoOPreset_TRACE;
struct OPS  *record_key_next_val_ops;
struct OPS *array_of_record_key_next_val_table;
struct OPS *array_of_record_key_next_val_ops;
struct OPS *array_of_record_key_next_val_ops;
OWNPTR array_of_record_key_next_val_owns;
static int gcoOPreset_own_init = 0;

/**** BEGIN PROCEDURE reset ****/

errcode gcoOPreset()
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        } locals;
    locals.DBG_INFO = dbg_info_gcoOPreset;
        if (gcoOPreset_own_init == 0) {
        if (gco_own_init == 0) {
            locals.err = gco_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcoOPreset_own_init = 1;
    }
    enter_proc(390);

  LINE(391);
    {
    CLUREF T_1_1;
    locals.err = arrayOPnew(&T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    gcoOPobj_store.num = T_1_1.num;
    }
    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 reset ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist2 *locals;
    Vlist7 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcoOPreset_actual;
static Vlist0 vals_gcoOPreset = {0, 0};
static siglist0 sigs_gcoOPreset = {0, 0};
static Vlist2 locals_gcoOPreset = {0, 2,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops}}
};
static Vlist0 popowns_gcoOPreset = {0, 0};
Slist0 tformals_gcoOPreset = {0, 0};
Slist0 opformals_gcoOPreset = {0, 0};
dbg_info_gcoOPreset_actual dbg_info_gcoOPreset_data = {0, 12, 
    "gcoOPreset", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcoOPreset, 0, 
    &vals_gcoOPreset, &sigs_gcoOPreset, &locals_gcoOPreset, &owns_gco, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcoOPreset = (struct dbg_info*)&dbg_info_gcoOPreset_data;
extern struct dbg_info* dbg_info_gcoOPdebug_print;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG gcoOPdebug_print_TRACE
int gcoOPdebug_print_TRACE;
static int gcoOPdebug_print_own_init = 0;

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

errcode gcoOPdebug_print(_rep, ps)
CLUREF _rep;
CLUREF ps;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF _rep;
        CLUREF ps;
        } locals;
    locals._rep.num = UNINIT;
    locals.ps.num = UNINIT;
    locals.DBG_INFO = dbg_info_gcoOPdebug_print;
    locals._rep = _rep;
    locals.ps = ps;
        if (gcoOPdebug_print_own_init == 0) {
        if (gco_own_init == 0) {
            locals.err = gco_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        gcoOPdebug_print_own_init = 1;
    }
    enter_proc(1);

  LINE(2);
    {
    locals.err = nullOPdebug_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 ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist7 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_gcoOPdebug_print_actual;
static Vlist0 vals_gcoOPdebug_print = {0, 0};
static siglist0 sigs_gcoOPdebug_print = {0, 0};
static Vlist4 locals_gcoOPdebug_print = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "_rep", &null_ops},  {0, 2, "ps", &pstream_ops}}
};
static Vlist0 popowns_gcoOPdebug_print = {0, 0};
Slist0 tformals_gcoOPdebug_print = {0, 0};
Slist0 opformals_gcoOPdebug_print = {0, 0};
dbg_info_gcoOPdebug_print_actual dbg_info_gcoOPdebug_print_data = {0, 12, 
    "gcoOPdebug_print", "/common/pub/dcurtis-temp/pclu/lib/clu/gc_read.clu", 0, 0, (int)gcoOPdebug_print, 2, 
    &vals_gcoOPdebug_print, &sigs_gcoOPdebug_print, &locals_gcoOPdebug_print, &owns_gco, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_gcoOPdebug_print = (struct dbg_info*)&dbg_info_gcoOPdebug_print_data;
typedef struct{
    int count;
    OWNPTR type_owns;
    OWNPTR op_owns;
    struct OP_ENTRY entry[5];
} gco_OPS;

CLU_proc gco_oe_get_obj = {{0,0,0,0}, gcoOPget_obj, 0};
CLU_proc gco_oe_init = {{0,0,0,0}, gcoOPinit, 0};
CLU_proc gco_oe_reset = {{0,0,0,0}, gcoOPreset, 0};
CLU_proc gco_oe_save_new_obj = {{0,0,0,0}, gcoOPsave_new_obj, 0};
CLU_proc gco_oe_debug_print = {{0,0,0,0}, gcoOPdebug_print, 0};

gco_OPS gco_ops_actual = {5, (OWNPTR)&gco_own_init, (OWNPTR)&gco_own_init, {
    {&gco_oe_get_obj, "get_obj"},
    {&gco_oe_init, "init"},
    {&gco_oe_reset, "reset"},
    {&gco_oe_save_new_obj, "save_new_obj"},
    {&gco_oe_debug_print, "debug_print"}}};

struct OPS *gco_ops = (struct OPS *)&gco_ops_actual;

/**** END CLUSTER gco ****/