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

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


/**** BEGIN CLUSTER heap ****/


typedef struct {
int count;
} heap_of_t_REQS;

heap_of_t_REQS heap_of_t_reqs_actual = {0};

struct REQS * heap_of_t_reqs = (struct REQS *)&heap_of_t_reqs_actual;


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

extern errcode arrayOPcreate();
extern errcode arrayOPbottom();
extern errcode recordOPget_1();
extern errcode arrayOPsize();
extern errcode intOPequal();
extern errcode recordOPget_2();
extern errcode arrayOPaddh();
extern errcode arrayOPhigh();
extern errcode intOPdiv();
extern errcode intOPgt();
extern errcode arrayOPfetch();
extern errcode arrayOPstore();
extern errcode arrayOPremh();
extern errcode intOPle();
extern errcode intOPmul();
extern errcode intOPlt();
extern errcode intOPadd();
extern errcode recordOPcopy1();
extern errcode recordOPset_1();
extern errcode arrayOPcopy1();
extern errcode recordOPdebug_print();
extern struct REQS *array_of_t_reqs;
extern OWN_req array_ownreqs;
extern struct OPS *array_ops;
extern struct OPS *array_of_t_ops;
extern struct OPS *proctype_ops;
extern OWN_req int_ownreqs;
extern struct OPS *int_ops;

OWN_ptr heap_own_init; /* dummy */
typedef struct {
    int heap_own_init;
    int create_own_init;
    int top_own_init;
    int size_own_init;
    int empty_own_init;
    int insert_own_init;
    int remove_own_init;
    int copy_own_init;
    int debug_print_own_init;
    heap_of_t_OPS *t_ops;
    struct OPS *array_of_t_table;
    struct OPS *array_of_t_ops;
    OWNPTR array_of_t_owns;
    struct OPS  *record_a_p_ops;
} heap_OWN_DEFN;

OWN_req heap_ownreqs = {sizeof(heap_OWN_DEFN), 9};

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

enter_own_init_proc();
    if (locals.type_own_ptr->heap_own_init == 0) {
    add_parm_info_type(0, locals.type_own_ptr->t_ops, array_of_t_reqs);
    find_type_instance(array_ops, 1, &array_ownreqs, &(locals.type_own_ptr->array_of_t_ops));
    add_selector_info("a", 0, locals.type_own_ptr->array_of_t_ops); 
    add_selector_info("p", 1, proctype_ops); 
    find_selector_ops("record", 2, &(locals.type_own_ptr->record_a_p_ops));
    }
    if (locals.type_own_ptr->heap_own_init == 0) {
    locals.type_own_ptr->heap_own_init = 1;
    {signal(ERR_ok);}
    ex_0: pclu_unhandled(locals.err); {signal(ERR_failure);}
}
}

extern struct dbg_info* dbg_info_heapOPcreate;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG heapOPcreate_TRACE
int heapOPcreate_TRACE;
static Vlist14 ptowns_heap = {0, 14,{ {0, 2, "heap_init", &int_ops}
, {0, 2, "heapOPcreate_init", &int_ops}
, {0, 2, "heapOPcreate_init", &int_ops}
, {0, 2, "heapOPcreate_init", &int_ops}
, {0, 2, "heapOPcreate_init", &int_ops}
, {0, 2, "heapOPcreate_init", &int_ops}
, {0, 2, "heapOPcreate_init", &int_ops}
, {0, 2, "heapOPcreate_init", &int_ops}
, {0, 2, "heapOPcreate_init", &int_ops}
,{0, 2, "t_ops", &int_ops}
,{0, 2, "array_of_t_table", &int_ops}
,{0, 2, "array_of_t_ops", &int_ops}
,{0, 2, "array_of_t_owns", &int_ops}
,{0, 2, "record_a_p_ops", &int_ops}
}};

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

errcode heapOPcreate(p, ret_1)
CLUREF p;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        heap_OWN_DEFN *type_own_ptr;
        CLUREF p;
        } locals;
    locals.p.num = UNINIT;
    locals.DBG_INFO = dbg_info_heapOPcreate;
    locals.p = p;
    locals.type_own_ptr = (heap_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->create_own_init == 0) {
        add_parm_info_type(0, locals.type_own_ptr->t_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(locals.type_own_ptr->array_of_t_ops));
        add_selector_info("a", 0, locals.type_own_ptr->array_of_t_ops); 
        add_selector_info("p", 1, proctype_ops); 
        find_selector_ops("record", 2, &(locals.type_own_ptr->record_a_p_ops));
        }
        if (locals.type_own_ptr->create_own_init == 0) {
        locals.type_own_ptr->create_own_init = 1;
    }
    enter_proc(45);

  LINE(46);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    RecordAlloc(2, T_1_1);
    locals.err = arrayOPcreate(CLU_1, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_1.vec->data[0]  = T_1_2.num;
    T_1_1.vec->data[1]  = locals.p.num;
    ret_1->num = T_1_1.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE create ****/

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;
    Vlist0 *owns;
    Vlist14 *ptowns;
    Vlist0 *popowns;
    Slist1 *type_formals;
    Slist0 *op_formals;
    } dbg_info_heapOPcreate_actual;
static Vlist1 vals_heapOPcreate = {0, 1, { {0, 2, "", zero_ops, "record_a_p_ops"}}
};
static siglist0 sigs_heapOPcreate = {0, 0};
static Vlist4 locals_heapOPcreate = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "p", m1_ops}}
};
static Vlist0 popowns_heapOPcreate = {0, 0};
Slist1 tformals_heapOPcreate = {0, 1, "t"};
Slist0 opformals_heapOPcreate = {0, 0};
dbg_info_heapOPcreate_actual dbg_info_heapOPcreate_data = {0, 12, 
    "heapOPcreate", "/common/pub/dcurtis-temp/pclu/lib/clu/heap.clu", 0, 2, (int)heapOPcreate, 1, 
    &vals_heapOPcreate, &sigs_heapOPcreate, &locals_heapOPcreate, &NO_VALS, &ptowns_heap, &NO_VALS, &tformals_heapOPcreate, &NO_PARMS};
    struct dbg_info *dbg_info_heapOPcreate = (struct dbg_info*)&dbg_info_heapOPcreate_data;
extern struct dbg_info* dbg_info_heapOPtop;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG heapOPtop_TRACE
int heapOPtop_TRACE;

/**** BEGIN PROCEDURE top ****/

errcode heapOPtop(x, ret_1)
CLUREF x;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        heap_OWN_DEFN *type_own_ptr;
        CLUREF x;
        } locals;
    locals.x.num = UNINIT;
    locals.DBG_INFO = dbg_info_heapOPtop;
    locals.x = x;
    locals.type_own_ptr = (heap_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->top_own_init == 0) {
        add_parm_info_type(0, locals.type_own_ptr->t_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(locals.type_own_ptr->array_of_t_ops));
        add_selector_info("a", 0, locals.type_own_ptr->array_of_t_ops); 
        add_selector_info("p", 1, proctype_ops); 
        find_selector_ops("record", 2, &(locals.type_own_ptr->record_a_p_ops));
        }
        if (locals.type_own_ptr->top_own_init == 0) {
        locals.type_own_ptr->top_own_init = 1;
    }
    enter_proc(49);

  LINE(50);
    {
    {
    CLUREF T_2_1;
    CLUREF T_2_2;
    T_2_1.num = locals.x.vec->data[0];
    locals.err = arrayOPbottom(T_2_1, &T_2_2);
    if (locals.err != ERR_ok) goto ex_1;
    ret_1->num = T_2_2.num;
    }
    {signal (ERR_ok);}}
        goto end_1;
        ex_1:
            if ((locals.err == ERR_bounds)) {

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

/**** END PROCEDURE top ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist4 *locals;
    Vlist0 *owns;
    Vlist14 *ptowns;
    Vlist0 *popowns;
    Slist1 *type_formals;
    Slist0 *op_formals;
    } dbg_info_heapOPtop_actual;
static Vlist1 vals_heapOPtop = {0, 1, { {0, 2, "", zero_ops, "t_ops"}}
};
static sig_desc0 sig_heapOPtop_1 = {0, 3, "empty", {0, 0
}};
static siglist1 sigs_heapOPtop = {0, 1, (sig_desc*)&sig_heapOPtop_1};
static Vlist4 locals_heapOPtop = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "x", zero_ops, "record_a_p_ops"}}
};
static Vlist0 popowns_heapOPtop = {0, 0};
Slist1 tformals_heapOPtop = {0, 1, "t"};
Slist0 opformals_heapOPtop = {0, 0};
dbg_info_heapOPtop_actual dbg_info_heapOPtop_data = {0, 12, 
    "heapOPtop", "/common/pub/dcurtis-temp/pclu/lib/clu/heap.clu", 0, 2, (int)heapOPtop, 1, 
    &vals_heapOPtop, &sigs_heapOPtop, &locals_heapOPtop, &NO_VALS, &ptowns_heap, &NO_VALS, &tformals_heapOPtop, &NO_PARMS};
    struct dbg_info *dbg_info_heapOPtop = (struct dbg_info*)&dbg_info_heapOPtop_data;
extern struct dbg_info* dbg_info_heapOPsize;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG heapOPsize_TRACE
int heapOPsize_TRACE;

/**** BEGIN PROCEDURE size ****/

errcode heapOPsize(x, ret_1)
CLUREF x;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        heap_OWN_DEFN *type_own_ptr;
        CLUREF x;
        } locals;
    locals.x.num = UNINIT;
    locals.DBG_INFO = dbg_info_heapOPsize;
    locals.x = x;
    locals.type_own_ptr = (heap_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->size_own_init == 0) {
        add_parm_info_type(0, locals.type_own_ptr->t_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(locals.type_own_ptr->array_of_t_ops));
        add_selector_info("a", 0, locals.type_own_ptr->array_of_t_ops); 
        add_selector_info("p", 1, proctype_ops); 
        find_selector_ops("record", 2, &(locals.type_own_ptr->record_a_p_ops));
        }
        if (locals.type_own_ptr->size_own_init == 0) {
        locals.type_own_ptr->size_own_init = 1;
    }
    enter_proc(54);

  LINE(55);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.x.vec->data[0];
    T_1_2.num = T_1_1.array->ext_size;
    ret_1->num = T_1_2.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE 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;
    Vlist0 *owns;
    Vlist14 *ptowns;
    Vlist0 *popowns;
    Slist1 *type_formals;
    Slist0 *op_formals;
    } dbg_info_heapOPsize_actual;
static Vlist1 vals_heapOPsize = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_heapOPsize = {0, 0};
static Vlist4 locals_heapOPsize = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "x", zero_ops, "record_a_p_ops"}}
};
static Vlist0 popowns_heapOPsize = {0, 0};
Slist1 tformals_heapOPsize = {0, 1, "t"};
Slist0 opformals_heapOPsize = {0, 0};
dbg_info_heapOPsize_actual dbg_info_heapOPsize_data = {0, 12, 
    "heapOPsize", "/common/pub/dcurtis-temp/pclu/lib/clu/heap.clu", 0, 2, (int)heapOPsize, 1, 
    &vals_heapOPsize, &sigs_heapOPsize, &locals_heapOPsize, &NO_VALS, &ptowns_heap, &NO_VALS, &tformals_heapOPsize, &NO_PARMS};
    struct dbg_info *dbg_info_heapOPsize = (struct dbg_info*)&dbg_info_heapOPsize_data;
extern struct dbg_info* dbg_info_heapOPempty;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG heapOPempty_TRACE
int heapOPempty_TRACE;

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

errcode heapOPempty(x, ret_1)
CLUREF x;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        heap_OWN_DEFN *type_own_ptr;
        CLUREF x;
        } locals;
    locals.x.num = UNINIT;
    locals.DBG_INFO = dbg_info_heapOPempty;
    locals.x = x;
    locals.type_own_ptr = (heap_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->empty_own_init == 0) {
        add_parm_info_type(0, locals.type_own_ptr->t_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(locals.type_own_ptr->array_of_t_ops));
        add_selector_info("a", 0, locals.type_own_ptr->array_of_t_ops); 
        add_selector_info("p", 1, proctype_ops); 
        find_selector_ops("record", 2, &(locals.type_own_ptr->record_a_p_ops));
        }
        if (locals.type_own_ptr->empty_own_init == 0) {
        locals.type_own_ptr->empty_own_init = 1;
    }
    enter_proc(58);

  LINE(59);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    T_1_1.num = locals.x.vec->data[0];
    T_1_2.num = T_1_1.array->ext_size;
    T_1_3.num = (T_1_2.num == 0)? true : false;
    ret_1->num = T_1_3.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE empty ****/

extern struct OPS *bool_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist0 *owns;
    Vlist14 *ptowns;
    Vlist0 *popowns;
    Slist1 *type_formals;
    Slist0 *op_formals;
    } dbg_info_heapOPempty_actual;
static Vlist1 vals_heapOPempty = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_heapOPempty = {0, 0};
static Vlist4 locals_heapOPempty = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "x", zero_ops, "record_a_p_ops"}}
};
static Vlist0 popowns_heapOPempty = {0, 0};
Slist1 tformals_heapOPempty = {0, 1, "t"};
Slist0 opformals_heapOPempty = {0, 0};
dbg_info_heapOPempty_actual dbg_info_heapOPempty_data = {0, 12, 
    "heapOPempty", "/common/pub/dcurtis-temp/pclu/lib/clu/heap.clu", 0, 2, (int)heapOPempty, 1, 
    &vals_heapOPempty, &sigs_heapOPempty, &locals_heapOPempty, &NO_VALS, &ptowns_heap, &NO_VALS, &tformals_heapOPempty, &NO_PARMS};
    struct dbg_info *dbg_info_heapOPempty = (struct dbg_info*)&dbg_info_heapOPempty_data;
extern struct dbg_info* dbg_info_heapOPinsert;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG heapOPinsert_TRACE
int heapOPinsert_TRACE;

/**** BEGIN PROCEDURE insert ****/

errcode heapOPinsert(x, v)
CLUREF x;
CLUREF v;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        heap_OWN_DEFN *type_own_ptr;
        CLUREF a;
        CLUREF p;
        CLUREF son;
        CLUREF dad;
        CLUREF x;
        CLUREF v;
        } locals;
    locals.a.num = UNINIT;
    locals.p.num = UNINIT;
    locals.son.num = UNINIT;
    locals.dad.num = UNINIT;
    locals.x.num = UNINIT;
    locals.v.num = UNINIT;
    locals.DBG_INFO = dbg_info_heapOPinsert;
    locals.x = x;
    locals.v = v;
    locals.type_own_ptr = (heap_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->insert_own_init == 0) {
        add_parm_info_type(0, locals.type_own_ptr->t_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(locals.type_own_ptr->array_of_t_ops));
        add_selector_info("a", 0, locals.type_own_ptr->array_of_t_ops); 
        add_selector_info("p", 1, proctype_ops); 
        find_selector_ops("record", 2, &(locals.type_own_ptr->record_a_p_ops));
        }
        if (locals.type_own_ptr->insert_own_init == 0) {
        locals.type_own_ptr->insert_own_init = 1;
    }
    enter_proc(62);

  LINE(63);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.x.vec->data[0];
        locals.a.num = T_1_1.num;
        }
        }

  LINE(64);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.x.vec->data[1];
        locals.p.num = T_1_1.num;
        }
        }

  LINE(65);
    {
    locals.err = arrayOPaddh(locals.a, locals.v);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(66);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.a.array->ext_high;
        locals.son.num = T_1_1.num;
        }
        }

  LINE(67);
    {
        {CLUREF T_1_1;
        locals.err = intOPdiv(locals.son, CLU_2, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.dad.num = T_1_1.num;
        }
        }

  LINE(68);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        T_1_2.num = (locals.dad.num > 0)? true : false;
        T_1_1.num = T_1_2.num;
        if (T_1_2.num) {
            locals.err = arrayOPfetch(locals.a, locals.dad, &T_1_3);
            if (locals.err != ERR_ok) goto ex_0;
            CUR_PROC_VAR = locals.p;
            locals.err = locals.p.proc->proc(locals.v, T_1_3, &T_1_4);
            if (locals.err != ERR_ok) goto ex_0;
            T_1_1.num = T_1_4.num;
        }
        if (T_1_1.num != true) { break; }

  LINE(69);
        {
        CLUREF T_2_1;
        locals.err = arrayOPfetch(locals.a, locals.dad, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = arrayOPstore(locals.a, locals.son, T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(70);
        {
        CLUREF T_2_1;
        locals.err = intOPdiv(locals.dad, CLU_2, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.son.num = locals.dad.num;
        locals.dad.num = T_2_1.num;
        }
        }
        end_while_1:;

  LINE(72);
    {
    locals.err = arrayOPstore(locals.a, locals.son, locals.v);
    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 insert ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist9 *locals;
    Vlist0 *owns;
    Vlist14 *ptowns;
    Vlist0 *popowns;
    Slist1 *type_formals;
    Slist0 *op_formals;
    } dbg_info_heapOPinsert_actual;
static Vlist0 vals_heapOPinsert = {0, 0};
static siglist0 sigs_heapOPinsert = {0, 0};
static Vlist9 locals_heapOPinsert = {0, 9,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "a", zero_ops, "array_of_t_ops"},  {0, 2, "p", m1_ops},  {0, 2, "son", &int_ops},  {0, 2, "dad", &int_ops},  {0, 2, "x", zero_ops, "record_a_p_ops"},  {0, 2, "v", zero_ops, "t_ops"}}
};
static Vlist0 popowns_heapOPinsert = {0, 0};
Slist1 tformals_heapOPinsert = {0, 1, "t"};
Slist0 opformals_heapOPinsert = {0, 0};
dbg_info_heapOPinsert_actual dbg_info_heapOPinsert_data = {0, 12, 
    "heapOPinsert", "/common/pub/dcurtis-temp/pclu/lib/clu/heap.clu", 0, 2, (int)heapOPinsert, 2, 
    &vals_heapOPinsert, &sigs_heapOPinsert, &locals_heapOPinsert, &NO_VALS, &ptowns_heap, &NO_VALS, &tformals_heapOPinsert, &NO_PARMS};
    struct dbg_info *dbg_info_heapOPinsert = (struct dbg_info*)&dbg_info_heapOPinsert_data;
extern struct dbg_info* dbg_info_heapOPremove;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG heapOPremove_TRACE
int heapOPremove_TRACE;

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

errcode heapOPremove(x, ret_1)
CLUREF x;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        heap_OWN_DEFN *type_own_ptr;
        CLUREF a;
        CLUREF p;
        CLUREF r;
        CLUREF v;
        CLUREF max_son;
        CLUREF max_dad;
        CLUREF dad;
        CLUREF son;
        CLUREF s;
        CLUREF ns;
        CLUREF x;
        } locals;
    locals.a.num = UNINIT;
    locals.p.num = UNINIT;
    locals.r.num = UNINIT;
    locals.v.num = UNINIT;
    locals.max_son.num = UNINIT;
    locals.max_dad.num = UNINIT;
    locals.dad.num = UNINIT;
    locals.son.num = UNINIT;
    locals.s.num = UNINIT;
    locals.ns.num = UNINIT;
    locals.x.num = UNINIT;
    locals.DBG_INFO = dbg_info_heapOPremove;
    locals.x = x;
    locals.type_own_ptr = (heap_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->remove_own_init == 0) {
        add_parm_info_type(0, locals.type_own_ptr->t_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(locals.type_own_ptr->array_of_t_ops));
        add_selector_info("a", 0, locals.type_own_ptr->array_of_t_ops); 
        add_selector_info("p", 1, proctype_ops); 
        find_selector_ops("record", 2, &(locals.type_own_ptr->record_a_p_ops));
        }
        if (locals.type_own_ptr->remove_own_init == 0) {
        locals.type_own_ptr->remove_own_init = 1;
    }
    enter_proc(75);

  LINE(76);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.x.vec->data[0];
        locals.a.num = T_1_1.num;
        }
        }

  LINE(77);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.x.vec->data[1];
        locals.p.num = T_1_1.num;
        }
        }

  LINE(78);
    {
        {CLUREF T_2_1;
        locals.err = arrayOPbottom(locals.a, &T_2_1);
        if (locals.err != ERR_ok) goto ex_1;
        locals.r.num = T_2_1.num;
        }
        }
        goto end_1;
        ex_1:
            if ((locals.err == ERR_bounds)) {

  LINE(79);
                {
                {signal (ERR_empty);}}
            }
            else {
                goto ex_0;
            }
        end_1:;

  LINE(80);
    {
        {CLUREF T_1_1;
        locals.err = arrayOPremh(locals.a, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.v.num = T_1_1.num;
        }
        }

  LINE(81);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.a.array->ext_size;
        locals.max_son.num = T_1_1.num;
        }
        }

  LINE(82);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals.max_son.num == 0)? true : false;
    if (T_1_1.num == true) {
        {
        {
        ret_1->num = locals.r.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(83);
    {
        {CLUREF T_1_1;
        locals.err = intOPdiv(locals.max_son, CLU_2, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.max_dad.num = T_1_1.num;
        }
        }

  LINE(84);
    {
        {locals.dad.num = 1;
        }
        }

  LINE(85);
    for (;;) {
        CLUREF T_1_1;
        T_1_1.num = (locals.dad.num <= locals.max_dad.num)? true : false;
        if (T_1_1.num != true) { break; }

  LINE(86);
        {
            {CLUREF T_2_1;
            locals.err = intOPmul(locals.dad, CLU_2, &T_2_1);
            if (locals.err != ERR_ok) goto ex_0;
            locals.son.num = T_2_1.num;
            }
            }

  LINE(87);
        {
            {CLUREF T_2_1;
            locals.err = arrayOPfetch(locals.a, locals.son, &T_2_1);
            if (locals.err != ERR_ok) goto ex_0;
            locals.s.num = T_2_1.num;
            }
            }

  LINE(88);
        {
        CLUREF T_2_1;
        T_2_1.num = (locals.son.num < locals.max_son.num)? true : false;
        if (T_2_1.num == true) {

  LINE(90);
            {
                {CLUREF T_3_1;
                CLUREF T_3_2;
                locals.err = intOPadd(locals.son, CLU_1, &T_3_1);
                if (locals.err != ERR_ok) goto ex_0;
                locals.err = arrayOPfetch(locals.a, T_3_1, &T_3_2);
                if (locals.err != ERR_ok) goto ex_0;
                locals.ns.num = T_3_2.num;
                }
                }

  LINE(91);
            {
            CLUREF T_3_1;
            CUR_PROC_VAR = locals.p;
            locals.err = locals.p.proc->proc(locals.ns, locals.s, &T_3_1);
            if (locals.err != ERR_ok) goto ex_0;
            if (T_3_1.num == true) {
                {
                CLUREF T_4_1;
                locals.err = intOPadd(locals.son, CLU_1, &T_4_1);
                if (locals.err != ERR_ok) goto ex_0;
                locals.son.num = T_4_1.num;
                locals.s.num = locals.ns.num;
                }
                }
                }/* end if */
            }
            }/* end if */

  LINE(93);
        {
        CLUREF T_2_1;
        CUR_PROC_VAR = locals.p;
        locals.err = locals.p.proc->proc(locals.v, locals.s, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        if (T_2_1.num == true) {
            goto end_while_1;
            }
            }/* end if */

  LINE(94);
        {
        locals.err = arrayOPstore(locals.a, locals.dad, locals.s);
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(95);
        {
        locals.dad.num = locals.son.num;
        }
        }
        end_while_1:;

  LINE(97);
    {
    locals.err = arrayOPstore(locals.a, locals.dad, locals.v);
    if (locals.err != ERR_ok) goto ex_0;
    }

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

/**** END PROCEDURE remove ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist14 *locals;
    Vlist0 *owns;
    Vlist14 *ptowns;
    Vlist0 *popowns;
    Slist1 *type_formals;
    Slist0 *op_formals;
    } dbg_info_heapOPremove_actual;
static Vlist1 vals_heapOPremove = {0, 1, { {0, 2, "", zero_ops, "t_ops"}}
};
static sig_desc0 sig_heapOPremove_1 = {0, 3, "empty", {0, 0
}};
static siglist1 sigs_heapOPremove = {0, 1, (sig_desc*)&sig_heapOPremove_1};
static Vlist14 locals_heapOPremove = {0, 14,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "a", zero_ops, "array_of_t_ops"},  {0, 2, "p", m1_ops},  {0, 2, "r", zero_ops, "t_ops"},  {0, 2, "v", zero_ops, "t_ops"},  {0, 2, "max_son", &int_ops},  {0, 2, "max_dad", &int_ops},  {0, 2, "dad", &int_ops},  {0, 2, "son", &int_ops},  {0, 2, "s", zero_ops, "t_ops"},  {0, 2, "ns", zero_ops, "t_ops"},  {0, 2, "x", zero_ops, "record_a_p_ops"}}
};
static Vlist0 popowns_heapOPremove = {0, 0};
Slist1 tformals_heapOPremove = {0, 1, "t"};
Slist0 opformals_heapOPremove = {0, 0};
dbg_info_heapOPremove_actual dbg_info_heapOPremove_data = {0, 12, 
    "heapOPremove", "/common/pub/dcurtis-temp/pclu/lib/clu/heap.clu", 0, 2, (int)heapOPremove, 1, 
    &vals_heapOPremove, &sigs_heapOPremove, &locals_heapOPremove, &NO_VALS, &ptowns_heap, &NO_VALS, &tformals_heapOPremove, &NO_PARMS};
    struct dbg_info *dbg_info_heapOPremove = (struct dbg_info*)&dbg_info_heapOPremove_data;
extern struct dbg_info* dbg_info_heapOPcopy;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG heapOPcopy_TRACE
int heapOPcopy_TRACE;

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

errcode heapOPcopy(x, ret_1)
CLUREF x;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        heap_OWN_DEFN *type_own_ptr;
        CLUREF x;
        } locals;
    locals.x.num = UNINIT;
    locals.DBG_INFO = dbg_info_heapOPcopy;
    locals.x = x;
    locals.type_own_ptr = (heap_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->copy_own_init == 0) {
        add_parm_info_type(0, locals.type_own_ptr->t_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(locals.type_own_ptr->array_of_t_ops));
        add_selector_info("a", 0, locals.type_own_ptr->array_of_t_ops); 
        add_selector_info("p", 1, proctype_ops); 
        find_selector_ops("record", 2, &(locals.type_own_ptr->record_a_p_ops));
        }
        if (locals.type_own_ptr->copy_own_init == 0) {
        locals.type_own_ptr->copy_own_init = 1;
    }
    enter_proc(101);

  LINE(102);
    {
    CLUREF T_1_1;
    generic_CLU_proc.type_owns = 0;
    generic_CLU_proc.proc = recordOPcopy1;
    CUR_PROC_VAR.proc = &generic_CLU_proc;
    locals.err = recordOPcopy1(locals.x, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    locals.x.num = T_1_1.num;
    }

  LINE(103);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.x.vec->data[0];
    locals.err = arrayOPcopy1(T_1_1, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.x.vec->data[0]  = T_1_2.num;
    }

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

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

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist0 *owns;
    Vlist14 *ptowns;
    Vlist0 *popowns;
    Slist1 *type_formals;
    Slist0 *op_formals;
    } dbg_info_heapOPcopy_actual;
static Vlist1 vals_heapOPcopy = {0, 1, { {0, 2, "", zero_ops, "record_a_p_ops"}}
};
static siglist0 sigs_heapOPcopy = {0, 0};
static Vlist4 locals_heapOPcopy = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "x", zero_ops, "record_a_p_ops"}}
};
static Vlist0 popowns_heapOPcopy = {0, 0};
Slist1 tformals_heapOPcopy = {0, 1, "t"};
Slist0 opformals_heapOPcopy = {0, 0};
dbg_info_heapOPcopy_actual dbg_info_heapOPcopy_data = {0, 12, 
    "heapOPcopy", "/common/pub/dcurtis-temp/pclu/lib/clu/heap.clu", 0, 2, (int)heapOPcopy, 1, 
    &vals_heapOPcopy, &sigs_heapOPcopy, &locals_heapOPcopy, &NO_VALS, &ptowns_heap, &NO_VALS, &tformals_heapOPcopy, &NO_PARMS};
    struct dbg_info *dbg_info_heapOPcopy = (struct dbg_info*)&dbg_info_heapOPcopy_data;
extern struct dbg_info* dbg_info_heapOPdebug_print;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG heapOPdebug_print_TRACE
int heapOPdebug_print_TRACE;

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

errcode heapOPdebug_print(_rep, ps)
CLUREF _rep;
CLUREF ps;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        heap_OWN_DEFN *type_own_ptr;
        CLUREF _rep;
        CLUREF ps;
        } locals;
    locals._rep.num = UNINIT;
    locals.ps.num = UNINIT;
    locals.DBG_INFO = dbg_info_heapOPdebug_print;
    locals._rep = _rep;
    locals.ps = ps;
    locals.type_own_ptr = (heap_OWN_DEFN *) CUR_PROC_VAR.proc->type_owns;
        if (locals.type_own_ptr->debug_print_own_init == 0) {
        add_parm_info_type(0, locals.type_own_ptr->t_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(locals.type_own_ptr->array_of_t_ops));
        add_selector_info("a", 0, locals.type_own_ptr->array_of_t_ops); 
        add_selector_info("p", 1, proctype_ops); 
        find_selector_ops("record", 2, &(locals.type_own_ptr->record_a_p_ops));
        }
        if (locals.type_own_ptr->debug_print_own_init == 0) {
        locals.type_own_ptr->debug_print_own_init = 1;
    }
    enter_proc(1);

  LINE(2);
    {
    generic_CLU_proc.type_owns = 0;
    generic_CLU_proc.op_owns = locals.type_own_ptr->record_a_p_ops->entry[7].fcn->op_owns;
    generic_CLU_proc.proc = recordOPdebug_print;
    CUR_PROC_VAR.proc = &generic_CLU_proc;
    locals.err = recordOPdebug_print(locals._rep, locals.ps);
    if (locals.err != ERR_ok) goto ex_0;
    }
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

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

extern struct OPS *pstream_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist0 *sigs;
    Vlist5 *locals;
    Vlist0 *owns;
    Vlist14 *ptowns;
    Vlist0 *popowns;
    Slist1 *type_formals;
    Slist0 *op_formals;
    } dbg_info_heapOPdebug_print_actual;
static Vlist0 vals_heapOPdebug_print = {0, 0};
static siglist0 sigs_heapOPdebug_print = {0, 0};
static Vlist5 locals_heapOPdebug_print = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "type_own_ptr", &int_ops},  {0, 2, "_rep", zero_ops, "record_a_p_ops"},  {0, 2, "ps", &pstream_ops}}
};
static Vlist0 popowns_heapOPdebug_print = {0, 0};
Slist1 tformals_heapOPdebug_print = {0, 1, "t"};
Slist0 opformals_heapOPdebug_print = {0, 0};
dbg_info_heapOPdebug_print_actual dbg_info_heapOPdebug_print_data = {0, 12, 
    "heapOPdebug_print", "/common/pub/dcurtis-temp/pclu/lib/clu/heap.clu", 0, 2, (int)heapOPdebug_print, 2, 
    &vals_heapOPdebug_print, &sigs_heapOPdebug_print, &locals_heapOPdebug_print, &NO_VALS, &ptowns_heap, &NO_VALS, &tformals_heapOPdebug_print, &NO_PARMS};
    struct dbg_info *dbg_info_heapOPdebug_print = (struct dbg_info*)&dbg_info_heapOPdebug_print_data;
typedef struct{
    int count;
    OWNPTR type_owns;
    OWNPTR op_owns;
    struct OP_ENTRY entry[8];
} heap_OPS;

CLU_proc heap_oe_copy = {{0,0,0,0}, heapOPcopy, 0};
CLU_proc heap_oe_create = {{0,0,0,0}, heapOPcreate, 0};
CLU_proc heap_oe_empty = {{0,0,0,0}, heapOPempty, 0};
CLU_proc heap_oe_insert = {{0,0,0,0}, heapOPinsert, 0};
CLU_proc heap_oe_remove = {{0,0,0,0}, heapOPremove, 0};
CLU_proc heap_oe_size = {{0,0,0,0}, heapOPsize, 0};
CLU_proc heap_oe_top = {{0,0,0,0}, heapOPtop, 0};
CLU_proc heap_oe_debug_print = {{0,0,0,0}, heapOPdebug_print, 0};

heap_OPS heap_ops_actual = {8, (OWNPTR)&heap_own_init, (OWNPTR)&heap_own_init, {
    {&heap_oe_copy, "copy"},
    {&heap_oe_create, "create"},
    {&heap_oe_empty, "empty"},
    {&heap_oe_insert, "insert"},
    {&heap_oe_remove, "remove"},
    {&heap_oe_size, "size"},
    {&heap_oe_top, "top"},
    {&heap_oe_debug_print, "debug_print"}}};

struct OPS *heap_ops = (struct OPS *)&heap_ops_actual;

/**** END CLUSTER heap ****/