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

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


/**** BEGIN CLUSTER pstream ****/

extern errcode pstream_IB_1();
extern errcode pstreamOPcreate();
extern errcode streamOPprimary_output();
extern errcode boolOPnot();
extern errcode streamOPcan_write();
extern errcode arrayOPnew();
extern errcode recordOPset_7();
extern errcode streamOPget_line_length();
extern errcode recordOPset_12();
extern errcode recordOPget_4();
extern errcode recordOPget_6();
extern errcode intOPadd();
extern errcode recordOPset_4();
extern errcode recordOPget_1();
extern errcode pstreamOPputs();
extern errcode arrayOPaddh();
extern errcode recordOPget_3();
extern errcode recordOPget_2();
extern errcode intOPgt();
extern errcode recordOPget_8();
extern errcode recordOPset_1();
extern errcode intOPsub();
extern errcode intOPge();
extern errcode arrayOPsize();
extern errcode arrayOPremh();
extern errcode intOPequal();
extern errcode streamOPputc();
extern errcode recordOPget_11();
extern errcode recordOPset_6();
extern errcode recordOPset_10();
extern errcode recordOPget_5();
extern errcode pstreamOPputsp();
extern errcode arrayOPtop();
extern errcode arrayOPstore();
extern errcode recordOPget_9();
extern errcode charOPequal();
extern errcode recordOPget_12();
extern errcode intOPlt();
extern errcode recordOPget_10();
extern errcode recordOPget_7();
extern errcode stringOPsize();
extern errcode pstreamOPtext();
extern errcode pstreamOPputspace();
extern errcode stringOPindexc();
extern errcode intOPle();
extern errcode streamOPputs();
extern errcode stringOPchars();
extern errcode streamOPputspace();
extern errcode recordOPset_8();
extern errcode recordOPset_9();
extern errcode recordOPset_5();
extern errcode streamOPget_page_length();
extern errcode recordOPequal();
extern errcode arrayOPtrim();
extern errcode intOPprint();
extern errcode file_nameOPprint();
extern errcode streamOPget_name();
extern errcode pstreamOPtextc();
extern errcode pstreamOPprint();
extern OWN_req bool_ownreqs;
extern struct OPS *bool_ops;
extern struct REQS *array_of_t_reqs;
extern struct OPS *int_ops;
extern OWN_req array_ownreqs;
extern struct OPS *array_ops;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
extern struct OPS *array_of_int_ops;
extern struct OPS *stream_ops;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
CLUREF STR__056_056_056;
CLUREF STR__040;
CLUREF STR_pstream_133;
CLUREF STR_d_040;
CLUREF STR_w_040f_040;
CLUREF STR_w_040i_040;
CLUREF STR_m_040;
CLUREF STR_s_040;
CLUREF STR__050internal_051;
static int pstream_own_init = 0;
OWN_req pstream_ownreqs = {0,0};
errcode pstream_own_init_proc()
{
struct {
    errcode err;
    } locals;
    enter_own_init_proc();
        if (pstream_own_init == 0) {
        add_parm_info_type(0, int_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(array_of_int_ops));
        add_selector_info("abort", 0, bool_ops); 
        add_selector_info("aindent", 1, array_of_int_ops); 
        add_selector_info("awidth", 2, array_of_int_ops); 
        add_selector_info("depth", 3, int_ops); 
        add_selector_info("flat", 4, bool_ops); 
        add_selector_info("hpos", 5, int_ops); 
        add_selector_info("llen", 6, int_ops); 
        add_selector_info("max_depth", 7, int_ops); 
        add_selector_info("max_width", 8, int_ops); 
        add_selector_info("rhpos", 9, int_ops); 
        add_selector_info("stream", 10, stream_ops); 
        add_selector_info("wrap", 11, bool_ops); 
        find_selector_ops("record", 12, &(record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops));
        stringOPcons("...", CLU_1, CLU_3, &STR__056_056_056);
        stringOPcons(" ", CLU_1, CLU_1, &STR__040);
        stringOPcons("pstream[", CLU_1, CLU_8, &STR_pstream_133);
        stringOPcons("d ", CLU_1, CLU_2, &STR_d_040);
        stringOPcons("w f ", CLU_1, CLU_4, &STR_w_040f_040);
        stringOPcons("w i ", CLU_1, CLU_4, &STR_w_040i_040);
        stringOPcons("m ", CLU_1, CLU_2, &STR_m_040);
        stringOPcons("s ", CLU_1, CLU_2, &STR_s_040);
        stringOPcons("(internal)", CLU_1, CLU_10, &STR__050internal_051);
        pstream_own_init = 1;
        {signal(ERR_ok);}
    ex_0: pclu_unhandled(locals.err); {signal(ERR_failure);}
        }
    }

extern struct dbg_info* dbg_info_pstreamOPprimary_output;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPprimary_output_TRACE
int pstreamOPprimary_output_TRACE;
extern struct OPS *pstream_ops;
static Vlist32 owns_pstream = {0, 32,{ {0, 2, "pstream_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
,  {0, 2, "po", &pstream_ops}, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
, {0, 2, "pstreamOPprimary_output_init", &int_ops}
}
};
extern OWN_req pstream_ownreqs;
static int pstreamOPprimary_output_own_init = 0;
CLUREF pstreamOPprimary_outputOPpo;

/**** BEGIN PROCEDURE primary_output ****/

errcode pstreamOPprimary_output(ret_1)
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        } locals;
    locals.DBG_INFO = dbg_info_pstreamOPprimary_output;
        if (pstreamOPprimary_output_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPprimary_output_own_init = 1;
        {
            {CLUREF T_0_1;
            CLUREF T_0_2;
            locals.err = streamOPprimary_output(&T_0_1);
            if (locals.err != ERR_ok) goto ex_0;
            locals.err = pstreamOPcreate(T_0_1, CLU_4, CLU_4, &T_0_2);
            if (locals.err != ERR_ok) goto ex_0;
            pstreamOPprimary_outputOPpo.num = T_0_2.num;
            }
            }
    }
    enter_proc(30);

  LINE(32);
    {
    {
    ret_1->num = pstreamOPprimary_outputOPpo.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 primary_output ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist2 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPprimary_output_actual;
static Vlist1 vals_pstreamOPprimary_output = {0, 1, { {0, 2, "", &pstream_ops}}
};
static siglist0 sigs_pstreamOPprimary_output = {0, 0};
static Vlist2 locals_pstreamOPprimary_output = {0, 2,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops}}
};
static Vlist0 popowns_pstreamOPprimary_output = {0, 0};
Slist0 tformals_pstreamOPprimary_output = {0, 0};
Slist0 opformals_pstreamOPprimary_output = {0, 0};
dbg_info_pstreamOPprimary_output_actual dbg_info_pstreamOPprimary_output_data = {0, 12, 
    "pstreamOPprimary_output", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPprimary_output, 0, 
    &vals_pstreamOPprimary_output, &sigs_pstreamOPprimary_output, &locals_pstreamOPprimary_output, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPprimary_output = (struct dbg_info*)&dbg_info_pstreamOPprimary_output_data;
extern struct dbg_info* dbg_info_pstreamOPcreate;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPcreate_TRACE
int pstreamOPcreate_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPcreate_own_init = 0;

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

errcode pstreamOPcreate(st, max_depth, max_width, ret_1)
CLUREF st;
CLUREF max_depth;
CLUREF max_width;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        CLUREF st;
        CLUREF max_depth;
        CLUREF max_width;
        } locals;
    locals.ps.num = UNINIT;
    locals.st.num = UNINIT;
    locals.max_depth.num = UNINIT;
    locals.max_width.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPcreate;
    locals.st = st;
    locals.max_depth = max_depth;
    locals.max_width = max_width;
        if (pstreamOPcreate_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPcreate_own_init = 1;
    }
    enter_proc(35);

  LINE(37);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    locals.err = streamOPcan_write(locals.st, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_2.num = T_1_1.num ^ 1;
    if (T_1_2.num == true) {

  LINE(38);
        {
        {signal (ERR_illegal_stream);}}
        }
        }/* end if */

  LINE(39);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        RecordAlloc(12, T_1_1);
        T_1_1.vec->data[10]  = locals.st.num;
        T_1_1.vec->data[4]  = false;
        T_1_1.vec->data[11]  = true;
        T_1_1.vec->data[0]  = false;
        T_1_1.vec->data[7]  = locals.max_depth.num;
        T_1_1.vec->data[8]  = locals.max_width.num;
        T_1_1.vec->data[3]  = 0;
        T_1_1.vec->data[5]  = 0;
        T_1_1.vec->data[9]  = 0;
        T_1_1.vec->data[6]  = 1073741823;
        locals.err = arrayOPnew(&T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        T_1_1.vec->data[2]  = T_1_2.num;
        locals.err = arrayOPnew(&T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        T_1_1.vec->data[1]  = T_1_3.num;
        locals.ps.num = T_1_1.num;
        }
        }

  LINE(51);
    {
    CLUREF T_2_1;
    locals.err = streamOPget_line_length(locals.st, &T_2_1);
    if (locals.err != ERR_ok) goto ex_1;
    locals.ps.vec->data[6]  = T_2_1.num;
    }
        goto end_1;
        ex_1:
            if ((locals.err == ERR_no_limit)) {

  LINE(52);
                {
                locals.ps.vec->data[11]  = false;
                }
            }
            else {
                goto ex_0;
            }
        end_1:;

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

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

extern struct OPS *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist6 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPcreate_actual;
static Vlist1 vals_pstreamOPcreate = {0, 1, { {0, 2, "", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops}}
};
static sig_desc0 sig_pstreamOPcreate_1 = {0, 3, "illegal_stream", {0, 0
}};
static siglist1 sigs_pstreamOPcreate = {0, 1, (sig_desc*)&sig_pstreamOPcreate_1};
static Vlist6 locals_pstreamOPcreate = {0, 6,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "st", &stream_ops},  {0, 2, "max_depth", &int_ops},  {0, 2, "max_width", &int_ops}}
};
static Vlist0 popowns_pstreamOPcreate = {0, 0};
Slist0 tformals_pstreamOPcreate = {0, 0};
Slist0 opformals_pstreamOPcreate = {0, 0};
dbg_info_pstreamOPcreate_actual dbg_info_pstreamOPcreate_data = {0, 12, 
    "pstreamOPcreate", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPcreate, 3, 
    &vals_pstreamOPcreate, &sigs_pstreamOPcreate, &locals_pstreamOPcreate, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPcreate = (struct dbg_info*)&dbg_info_pstreamOPcreate_data;
extern struct dbg_info* dbg_info_pstreamOPget_depth;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPget_depth_TRACE
int pstreamOPget_depth_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPget_depth_own_init = 0;

/**** BEGIN PROCEDURE get_depth ****/

errcode pstreamOPget_depth(x, ret_1)
CLUREF x;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF x;
        } locals;
    locals.x.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPget_depth;
    locals.x = x;
        if (pstreamOPget_depth_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPget_depth_own_init = 1;
    }
    enter_proc(56);

  LINE(57);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.x.vec->data[3];
    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_depth ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist3 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPget_depth_actual;
static Vlist1 vals_pstreamOPget_depth = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_pstreamOPget_depth = {0, 0};
static Vlist3 locals_pstreamOPget_depth = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "x", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops}}
};
static Vlist0 popowns_pstreamOPget_depth = {0, 0};
Slist0 tformals_pstreamOPget_depth = {0, 0};
Slist0 opformals_pstreamOPget_depth = {0, 0};
dbg_info_pstreamOPget_depth_actual dbg_info_pstreamOPget_depth_data = {0, 12, 
    "pstreamOPget_depth", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPget_depth, 1, 
    &vals_pstreamOPget_depth, &sigs_pstreamOPget_depth, &locals_pstreamOPget_depth, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPget_depth = (struct dbg_info*)&dbg_info_pstreamOPget_depth_data;
extern struct dbg_info* dbg_info_pstreamOPget_hpos;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPget_hpos_TRACE
int pstreamOPget_hpos_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPget_hpos_own_init = 0;

/**** BEGIN PROCEDURE get_hpos ****/

errcode pstreamOPget_hpos(x, ret_1)
CLUREF x;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF x;
        } locals;
    locals.x.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPget_hpos;
    locals.x = x;
        if (pstreamOPget_hpos_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPget_hpos_own_init = 1;
    }
    enter_proc(60);

  LINE(61);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.x.vec->data[5];
    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_hpos ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist3 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPget_hpos_actual;
static Vlist1 vals_pstreamOPget_hpos = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_pstreamOPget_hpos = {0, 0};
static Vlist3 locals_pstreamOPget_hpos = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "x", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops}}
};
static Vlist0 popowns_pstreamOPget_hpos = {0, 0};
Slist0 tformals_pstreamOPget_hpos = {0, 0};
Slist0 opformals_pstreamOPget_hpos = {0, 0};
dbg_info_pstreamOPget_hpos_actual dbg_info_pstreamOPget_hpos_data = {0, 12, 
    "pstreamOPget_hpos", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPget_hpos, 1, 
    &vals_pstreamOPget_hpos, &sigs_pstreamOPget_hpos, &locals_pstreamOPget_hpos, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPget_hpos = (struct dbg_info*)&dbg_info_pstreamOPget_hpos_data;
extern struct dbg_info* dbg_info_pstreamOPstart;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPstart_TRACE
int pstreamOPstart_TRACE;
extern OWN_req int_ownreqs;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPstart_own_init = 0;

/**** BEGIN PROCEDURE start ****/

errcode pstreamOPstart(ps, s, ret_1)
CLUREF ps;
CLUREF s;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF depth;
        CLUREF ps;
        CLUREF s;
        } locals;
    locals.depth.num = UNINIT;
    locals.ps.num = UNINIT;
    locals.s.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPstart;
    locals.ps = ps;
    locals.s = s;
        if (pstreamOPstart_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPstart_own_init = 1;
    }
    enter_proc(72);

  LINE(73);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        T_1_1.num = locals.ps.vec->data[3];
        locals.err = intOPadd(T_1_1, CLU_1, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.depth.num = T_1_2.num;
        }
        }

  LINE(74);
    {
    locals.ps.vec->data[3]  = locals.depth.num;
    }

  LINE(75);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps.vec->data[0];
    if (T_1_1.num == true) {

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

  LINE(77);
    {
    locals.err = pstreamOPputs(locals.ps, locals.s);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(78);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps.vec->data[2];
    locals.err = arrayOPaddh(T_1_1, CLU_0);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(79);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.ps.vec->data[1];
    T_1_2.num = locals.ps.vec->data[5];
    locals.err = arrayOPaddh(T_1_1, T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(80);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.ps.vec->data[7];
    T_1_2.num = (locals.depth.num > T_1_1.num)? true : false;
    if (T_1_2.num == true) {

  LINE(81);
        {
        locals.err = pstreamOPputs(locals.ps, STR__056_056_056);
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(82);
        {
        locals.ps.vec->data[0]  = true;
        }

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

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

/**** END PROCEDURE start ****/

extern struct OPS *string_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist5 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPstart_actual;
static Vlist1 vals_pstreamOPstart = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_pstreamOPstart = {0, 0};
static Vlist5 locals_pstreamOPstart = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "depth", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "s", &string_ops}}
};
static Vlist0 popowns_pstreamOPstart = {0, 0};
Slist0 tformals_pstreamOPstart = {0, 0};
Slist0 opformals_pstreamOPstart = {0, 0};
dbg_info_pstreamOPstart_actual dbg_info_pstreamOPstart_data = {0, 12, 
    "pstreamOPstart", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPstart, 2, 
    &vals_pstreamOPstart, &sigs_pstreamOPstart, &locals_pstreamOPstart, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPstart = (struct dbg_info*)&dbg_info_pstreamOPstart_data;
extern struct dbg_info* dbg_info_pstreamOPstop;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPstop_TRACE
int pstreamOPstop_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPstop_own_init = 0;

/**** BEGIN PROCEDURE stop ****/

errcode pstreamOPstop(ps, s, ret_1)
CLUREF ps;
CLUREF s;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF depth;
        CLUREF ps;
        CLUREF s;
        } locals;
    locals.depth.num = UNINIT;
    locals.ps.num = UNINIT;
    locals.s.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPstop;
    locals.ps = ps;
    locals.s = s;
        if (pstreamOPstop_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPstop_own_init = 1;
    }
    enter_proc(88);

  LINE(89);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        T_1_1.num = locals.ps.vec->data[3];
        locals.err = intOPsub(T_1_1, CLU_1, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.depth.num = T_1_2.num;
        }
        }

  LINE(90);
    {
    locals.ps.vec->data[3]  = locals.depth.num;
    }

  LINE(91);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    T_1_1.num = locals.ps.vec->data[1];
    T_1_2.num = T_1_1.array->ext_size;
    T_1_3.num = (locals.depth.num >= T_1_2.num)? true : false;
    if (T_1_3.num == true) {

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

  LINE(93);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.ps.vec->data[1];
    locals.err = arrayOPremh(T_1_1, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(94);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.ps.vec->data[2];
    locals.err = arrayOPremh(T_1_1, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(95);
    {
    locals.ps.vec->data[0]  = false;
    }

  LINE(96);
    {
    locals.err = pstreamOPputs(locals.ps, locals.s);
    if (locals.err != ERR_ok) goto ex_0;
    }

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

/**** END PROCEDURE stop ****/

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;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPstop_actual;
static Vlist1 vals_pstreamOPstop = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_pstreamOPstop = {0, 0};
static Vlist5 locals_pstreamOPstop = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "depth", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "s", &string_ops}}
};
static Vlist0 popowns_pstreamOPstop = {0, 0};
Slist0 tformals_pstreamOPstop = {0, 0};
Slist0 opformals_pstreamOPstop = {0, 0};
dbg_info_pstreamOPstop_actual dbg_info_pstreamOPstop_data = {0, 12, 
    "pstreamOPstop", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPstop, 2, 
    &vals_pstreamOPstop, &sigs_pstreamOPstop, &locals_pstreamOPstop, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPstop = (struct dbg_info*)&dbg_info_pstreamOPstop_data;
extern struct dbg_info* dbg_info_pstreamOPpause;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPpause_TRACE
int pstreamOPpause_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPpause_own_init = 0;

/**** BEGIN PROCEDURE pause ****/

errcode pstreamOPpause(ps, s, ret_1)
CLUREF ps;
CLUREF s;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF depth;
        CLUREF width;
        CLUREF ps;
        CLUREF s;
        } locals;
    locals.depth.num = UNINIT;
    locals.width.num = UNINIT;
    locals.ps.num = UNINIT;
    locals.s.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPpause;
    locals.ps = ps;
    locals.s = s;
        if (pstreamOPpause_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPpause_own_init = 1;
    }
    enter_proc(100);

  LINE(101);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps.vec->data[0];
    if (T_1_1.num == true) {

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

  LINE(103);
    {
        {CLUREF T_1_1;
        T_1_1.num = locals.ps.vec->data[3];
        locals.depth.num = T_1_1.num;
        }
        }

  LINE(104);
    {
    locals.err = pstreamOPputs(locals.ps, locals.s);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(105);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals.depth.num == 0)? true : false;
    if (T_1_1.num == true) {

  LINE(106);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.ps.vec->data[10];
        T_2_2.ch = '\n';
        locals.err = streamOPputc(T_2_1, T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(107);
        {
        locals.ps.vec->data[5]  = 0;
        }

  LINE(108);
        {
        locals.ps.vec->data[9]  = 0;
        }

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

  LINE(111);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps.vec->data[4];
    if (T_1_1.num == true) {

  LINE(112);
        {
        locals.err = pstreamOPputs(locals.ps, STR__040);
        if (locals.err != ERR_ok) goto ex_0;
        }
        }
    else {

  LINE(113);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.ps.vec->data[10];
        T_2_2.ch = '\n';
        locals.err = streamOPputc(T_2_1, T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(114);
        {
        locals.ps.vec->data[5]  = 0;
        }

  LINE(115);
        {
        locals.ps.vec->data[9]  = 0;
        }

  LINE(116);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.ps.vec->data[1];
        locals.err = arrayOPtop(T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = pstreamOPputsp(locals.ps, T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        }
        }}/* end if */

  LINE(118);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = locals.ps.vec->data[2];
        locals.err = arrayOPtop(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.width.num = T_1_3.num;
        }
        }

  LINE(119);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps.vec->data[2];
    locals.err = arrayOPstore(T_1_1, locals.depth, locals.width);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(120);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.ps.vec->data[8];
    T_1_2.num = (locals.width.num >= T_1_1.num)? true : false;
    if (T_1_2.num == true) {

  LINE(121);
        {
        locals.err = pstreamOPputs(locals.ps, STR__056_056_056);
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(122);
        {
        locals.ps.vec->data[0]  = true;
        }

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

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

/**** END PROCEDURE pause ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist6 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPpause_actual;
static Vlist1 vals_pstreamOPpause = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_pstreamOPpause = {0, 0};
static Vlist6 locals_pstreamOPpause = {0, 6,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "depth", &int_ops},  {0, 2, "width", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "s", &string_ops}}
};
static Vlist0 popowns_pstreamOPpause = {0, 0};
Slist0 tformals_pstreamOPpause = {0, 0};
Slist0 opformals_pstreamOPpause = {0, 0};
dbg_info_pstreamOPpause_actual dbg_info_pstreamOPpause_data = {0, 12, 
    "pstreamOPpause", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPpause, 2, 
    &vals_pstreamOPpause, &sigs_pstreamOPpause, &locals_pstreamOPpause, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPpause = (struct dbg_info*)&dbg_info_pstreamOPpause_data;
extern struct dbg_info* dbg_info_pstreamOPtext;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPtext_TRACE
int pstreamOPtext_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPtext_own_init = 0;

/**** BEGIN PROCEDURE text ****/

errcode pstreamOPtext(ps, s, ret_1)
CLUREF ps;
CLUREF s;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        CLUREF s;
        } locals;
    locals.ps.num = UNINIT;
    locals.s.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPtext;
    locals.ps = ps;
    locals.s = s;
        if (pstreamOPtext_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPtext_own_init = 1;
    }
    enter_proc(128);

  LINE(129);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps.vec->data[0];
    if (T_1_1.num == true) {

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

  LINE(131);
    {
    locals.err = pstreamOPputs(locals.ps, locals.s);
    if (locals.err != ERR_ok) goto ex_0;
    }

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

/**** END PROCEDURE text ****/

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;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPtext_actual;
static Vlist1 vals_pstreamOPtext = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_pstreamOPtext = {0, 0};
static Vlist4 locals_pstreamOPtext = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "s", &string_ops}}
};
static Vlist0 popowns_pstreamOPtext = {0, 0};
Slist0 tformals_pstreamOPtext = {0, 0};
Slist0 opformals_pstreamOPtext = {0, 0};
dbg_info_pstreamOPtext_actual dbg_info_pstreamOPtext_data = {0, 12, 
    "pstreamOPtext", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPtext, 2, 
    &vals_pstreamOPtext, &sigs_pstreamOPtext, &locals_pstreamOPtext, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPtext = (struct dbg_info*)&dbg_info_pstreamOPtext_data;
extern struct dbg_info* dbg_info_pstreamOPtextc;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPtextc_TRACE
int pstreamOPtextc_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPtextc_own_init = 0;

/**** BEGIN PROCEDURE textc ****/

errcode pstreamOPtextc(ps, c, ret_1)
CLUREF ps;
CLUREF c;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        CLUREF c;
        } locals;
    locals.ps.num = UNINIT;
    locals.c.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPtextc;
    locals.ps = ps;
    locals.c = c;
        if (pstreamOPtextc_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPtextc_own_init = 1;
    }
    enter_proc(135);

  LINE(136);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps.vec->data[0];
    if (T_1_1.num == true) {

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

  LINE(138);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.ch = '\n';
    T_1_2.num = (locals.c.ch == T_1_1.ch)? true : false;
    if (T_1_2.num == true) {

  LINE(139);
        {
        CLUREF T_2_1;
        T_2_1.num = locals.ps.vec->data[10];
        locals.err = streamOPputc(T_2_1, locals.c);
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(140);
        {
        locals.ps.vec->data[5]  = 0;
        }

  LINE(141);
        {
        locals.ps.vec->data[9]  = 0;
        }
        }
    else {

  LINE(142);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.ps.vec->data[5];
        locals.err = intOPadd(T_2_1, CLU_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.ps.vec->data[5]  = T_2_2.num;
        }

  LINE(143);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        CLUREF T_2_5;
        T_2_2.num = locals.ps.vec->data[11];
        T_2_1.num = T_2_2.num;
        if (!T_2_2.num) {
            T_2_3.num = locals.ps.vec->data[9];
            T_2_4.num = locals.ps.vec->data[6];
            T_2_5.num = (T_2_3.num < T_2_4.num)? true : false;
            T_2_1.num = T_2_5.num;
        }
        if (T_2_1.num == true) {

  LINE(144);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            CLUREF T_3_3;
            T_3_1.num = locals.ps.vec->data[9];
            T_3_2.num = locals.ps.vec->data[6];
            T_3_3.num = (T_3_1.num >= T_3_2.num)? true : false;
            if (T_3_3.num == true) {

  LINE(145);
                {
                CLUREF T_4_1;
                CLUREF T_4_2;
                T_4_1.num = locals.ps.vec->data[10];
                T_4_2.ch = '\n';
                locals.err = streamOPputc(T_4_1, T_4_2);
                if (locals.err != ERR_ok) goto ex_0;
                }

  LINE(146);
                {
                locals.ps.vec->data[9]  = 0;
                }
                }
                }/* end if */

  LINE(148);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.ps.vec->data[9];
            locals.err = intOPadd(T_3_1, CLU_1, &T_3_2);
            if (locals.err != ERR_ok) goto ex_0;
            locals.ps.vec->data[9]  = T_3_2.num;
            }

  LINE(149);
            {
            CLUREF T_3_1;
            T_3_1.num = locals.ps.vec->data[10];
            locals.err = streamOPputc(T_3_1, locals.c);
            if (locals.err != ERR_ok) goto ex_0;
            }
            }
            }/* end if */
        }}/* end if */

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

/**** END PROCEDURE textc ****/

extern struct OPS *char_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPtextc_actual;
static Vlist1 vals_pstreamOPtextc = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_pstreamOPtextc = {0, 0};
static Vlist4 locals_pstreamOPtextc = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "c", &char_ops}}
};
static Vlist0 popowns_pstreamOPtextc = {0, 0};
Slist0 tformals_pstreamOPtextc = {0, 0};
Slist0 opformals_pstreamOPtextc = {0, 0};
dbg_info_pstreamOPtextc_actual dbg_info_pstreamOPtextc_data = {0, 12, 
    "pstreamOPtextc", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPtextc, 2, 
    &vals_pstreamOPtextc, &sigs_pstreamOPtextc, &locals_pstreamOPtextc, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPtextc = (struct dbg_info*)&dbg_info_pstreamOPtextc_data;
extern struct dbg_info* dbg_info_pstreamOPputleft;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPputleft_TRACE
int pstreamOPputleft_TRACE;
static int pstreamOPputleft_own_init = 0;

/**** BEGIN PROCEDURE putleft ****/

errcode pstreamOPputleft(ps, s, size, ret_1)
CLUREF ps;
CLUREF s;
CLUREF size;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF diff;
        CLUREF b;
        CLUREF ps;
        CLUREF s;
        CLUREF size;
        } locals;
    locals.diff.num = UNINIT;
    locals.b.num = UNINIT;
    locals.ps.num = UNINIT;
    locals.s.num = UNINIT;
    locals.size.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPputleft;
    locals.ps = ps;
    locals.s = s;
    locals.size = size;
        if (pstreamOPputleft_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPputleft_own_init = 1;
    }
    enter_proc(155);

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

  LINE(158);
        {
        {signal (ERR_negative_field_width);}}
        }
        }/* end if */

  LINE(159);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        locals.err = stringOPsize(locals.s, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPsub(locals.size, T_1_1, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.diff.num = T_1_2.num;
        }
        }

  LINE(160);
    {
        {CLUREF T_1_1;
        locals.err = pstreamOPtext(locals.ps, locals.s, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.b.num = T_1_1.num;
        }
        }

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

  LINE(162);
        {
        CLUREF T_2_1;
        locals.err = pstreamOPputspace(locals.ps, locals.diff, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        }
        }
        }/* end if */

  LINE(163);
    {
    {
    ret_1->num = locals.b.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 putleft ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist7 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPputleft_actual;
static Vlist1 vals_pstreamOPputleft = {0, 1, { {0, 2, "", &bool_ops}}
};
static sig_desc0 sig_pstreamOPputleft_1 = {0, 3, "negative_field_width", {0, 0
}};
static siglist1 sigs_pstreamOPputleft = {0, 1, (sig_desc*)&sig_pstreamOPputleft_1};
static Vlist7 locals_pstreamOPputleft = {0, 7,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "diff", &int_ops},  {0, 2, "b", &bool_ops},  {0, 2, "ps", &pstream_ops},  {0, 2, "s", &string_ops},  {0, 2, "size", &int_ops}}
};
static Vlist0 popowns_pstreamOPputleft = {0, 0};
Slist0 tformals_pstreamOPputleft = {0, 0};
Slist0 opformals_pstreamOPputleft = {0, 0};
dbg_info_pstreamOPputleft_actual dbg_info_pstreamOPputleft_data = {0, 12, 
    "pstreamOPputleft", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPputleft, 3, 
    &vals_pstreamOPputleft, &sigs_pstreamOPputleft, &locals_pstreamOPputleft, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPputleft = (struct dbg_info*)&dbg_info_pstreamOPputleft_data;
extern struct dbg_info* dbg_info_pstreamOPputright;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPputright_TRACE
int pstreamOPputright_TRACE;
static int pstreamOPputright_own_init = 0;

/**** BEGIN PROCEDURE putright ****/

errcode pstreamOPputright(ps, s, size, ret_1)
CLUREF ps;
CLUREF s;
CLUREF size;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF diff;
        CLUREF ps;
        CLUREF s;
        CLUREF size;
        } locals;
    locals.diff.num = UNINIT;
    locals.ps.num = UNINIT;
    locals.s.num = UNINIT;
    locals.size.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPputright;
    locals.ps = ps;
    locals.s = s;
    locals.size = size;
        if (pstreamOPputright_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPputright_own_init = 1;
    }
    enter_proc(166);

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

  LINE(169);
        {
        {signal (ERR_negative_field_width);}}
        }
        }/* end if */

  LINE(170);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        locals.err = stringOPsize(locals.s, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPsub(locals.size, T_1_1, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.diff.num = T_1_2.num;
        }
        }

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

  LINE(172);
        {
        CLUREF T_2_1;
        locals.err = pstreamOPputspace(locals.ps, locals.diff, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        }
        }
        }/* end if */

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

/**** END PROCEDURE putright ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist6 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPputright_actual;
static Vlist1 vals_pstreamOPputright = {0, 1, { {0, 2, "", &bool_ops}}
};
static sig_desc0 sig_pstreamOPputright_1 = {0, 3, "negative_field_width", {0, 0
}};
static siglist1 sigs_pstreamOPputright = {0, 1, (sig_desc*)&sig_pstreamOPputright_1};
static Vlist6 locals_pstreamOPputright = {0, 6,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "diff", &int_ops},  {0, 2, "ps", &pstream_ops},  {0, 2, "s", &string_ops},  {0, 2, "size", &int_ops}}
};
static Vlist0 popowns_pstreamOPputright = {0, 0};
Slist0 tformals_pstreamOPputright = {0, 0};
Slist0 opformals_pstreamOPputright = {0, 0};
dbg_info_pstreamOPputright_actual dbg_info_pstreamOPputright_data = {0, 12, 
    "pstreamOPputright", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPputright, 3, 
    &vals_pstreamOPputright, &sigs_pstreamOPputright, &locals_pstreamOPputright, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPputright = (struct dbg_info*)&dbg_info_pstreamOPputright_data;
extern struct dbg_info* dbg_info_pstreamOPputspace;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPputspace_TRACE
int pstreamOPputspace_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPputspace_own_init = 0;

/**** BEGIN PROCEDURE putspace ****/

errcode pstreamOPputspace(ps, len, ret_1)
CLUREF ps;
CLUREF len;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        CLUREF len;
        } locals;
    locals.ps.num = UNINIT;
    locals.len.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPputspace;
    locals.ps = ps;
    locals.len = len;
        if (pstreamOPputspace_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPputspace_own_init = 1;
    }
    enter_proc(176);

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

  LINE(179);
        {
        {signal (ERR_negative_field_width);}}
        }
        }/* end if */

  LINE(180);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps.vec->data[0];
    if (T_1_1.num == true) {

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

  LINE(182);
    {
    locals.err = pstreamOPputsp(locals.ps, locals.len);
    if (locals.err != ERR_ok) goto ex_0;
    }

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

/**** END PROCEDURE putspace ****/

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;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPputspace_actual;
static Vlist1 vals_pstreamOPputspace = {0, 1, { {0, 2, "", &bool_ops}}
};
static sig_desc0 sig_pstreamOPputspace_1 = {0, 3, "negative_field_width", {0, 0
}};
static siglist1 sigs_pstreamOPputspace = {0, 1, (sig_desc*)&sig_pstreamOPputspace_1};
static Vlist4 locals_pstreamOPputspace = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "len", &int_ops}}
};
static Vlist0 popowns_pstreamOPputspace = {0, 0};
Slist0 tformals_pstreamOPputspace = {0, 0};
Slist0 opformals_pstreamOPputspace = {0, 0};
dbg_info_pstreamOPputspace_actual dbg_info_pstreamOPputspace_data = {0, 12, 
    "pstreamOPputspace", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPputspace, 2, 
    &vals_pstreamOPputspace, &sigs_pstreamOPputspace, &locals_pstreamOPputspace, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPputspace = (struct dbg_info*)&dbg_info_pstreamOPputspace_data;
extern struct dbg_info* dbg_info_pstreamOPputs;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPputs_TRACE
int pstreamOPputs_TRACE;
extern errcode pstreamOPputs_IB_1();
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPputs_own_init = 0;

/**** BEGIN PROCEDURE puts ****/

errcode pstreamOPputs(ps, s)
CLUREF ps;
CLUREF s;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF len;
        CLUREF c;
        CLUREF ps;
        CLUREF s;
        } locals;
    locals.len.num = UNINIT;
    locals.c.num = UNINIT;
    locals.ps.num = UNINIT;
    locals.s.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPputs;
    locals.ps = ps;
    locals.s = s;
        if (pstreamOPputs_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPputs_own_init = 1;
    }
    enter_proc(186);

  LINE(187);
    {
        {CLUREF T_1_1;
        locals.err = stringOPsize(locals.s, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.len.num = T_1_1.num;
        }
        }

  LINE(188);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals.len.num == 0)? true : false;
    if (T_1_1.num == true) {

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

  LINE(190);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.ps.vec->data[5];
    locals.err = intOPadd(T_1_1, locals.len, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.ps.vec->data[5]  = T_1_2.num;
    }

  LINE(191);
    {
    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;
    CLUREF T_1_9;
    CLUREF T_1_10;
    T_1_3.num = locals.ps.vec->data[11];
    T_1_4.num = T_1_3.num ^ 1;
    T_1_2.num = T_1_4.num;
    if (T_1_4.num) {
        T_1_5.num = locals.ps.vec->data[9];
        T_1_6.num = locals.ps.vec->data[6];
        T_1_7.num = (T_1_5.num >= T_1_6.num)? true : false;
        T_1_2.num = T_1_7.num;
    }
    T_1_1.num = T_1_2.num;
    if (T_1_2.num) {
        T_1_8.ch = '\n';
        locals.err = stringOPindexc(T_1_8, locals.s, &T_1_9);
        if (locals.err != ERR_ok) goto ex_0;
        T_1_10.num = (T_1_9.num == 0)? true : false;
        T_1_1.num = T_1_10.num;
    }
    if (T_1_1.num == true) {

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

  LINE(195);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.ps.vec->data[9];
    locals.err = intOPadd(T_1_1, locals.len, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.ps.vec->data[9]  = T_1_2.num;
    }

  LINE(196);
    {
    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;
    T_1_2.num = locals.ps.vec->data[9];
    T_1_3.num = locals.ps.vec->data[6];
    T_1_4.num = (T_1_2.num <= T_1_3.num)? true : false;
    T_1_1.num = T_1_4.num;
    if (T_1_4.num) {
        T_1_5.ch = '\n';
        locals.err = stringOPindexc(T_1_5, locals.s, &T_1_6);
        if (locals.err != ERR_ok) goto ex_0;
        T_1_7.num = (T_1_6.num == 0)? true : false;
        T_1_1.num = T_1_7.num;
    }
    if (T_1_1.num == true) {

  LINE(197);
        {
        CLUREF T_2_1;
        T_2_1.num = locals.ps.vec->data[10];
        locals.err = streamOPputs(T_2_1, locals.s);
        if (locals.err != ERR_ok) goto ex_0;
        }

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

  LINE(200);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.ps.vec->data[5];
    locals.err = intOPsub(T_1_1, locals.len, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.ps.vec->data[5]  = T_1_2.num;
    }

  LINE(201);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.ps.vec->data[9];
    locals.err = intOPsub(T_1_1, locals.len, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.ps.vec->data[9]  = T_1_2.num;
    }

  LINE(202);
    {
        locals.err = stringOPchars(locals.s, pstreamOPputs_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 puts ****/

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;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPputs_actual;
static Vlist0 vals_pstreamOPputs = {0, 0};
static siglist0 sigs_pstreamOPputs = {0, 0};
static Vlist6 locals_pstreamOPputs = {0, 6,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "len", &int_ops},  {0, 2, "c", &char_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "s", &string_ops}}
};
static Vlist0 popowns_pstreamOPputs = {0, 0};
Slist0 tformals_pstreamOPputs = {0, 0};
Slist0 opformals_pstreamOPputs = {0, 0};
dbg_info_pstreamOPputs_actual dbg_info_pstreamOPputs_data = {0, 12, 
    "pstreamOPputs", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPputs, 2, 
    &vals_pstreamOPputs, &sigs_pstreamOPputs, &locals_pstreamOPputs, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPputs = (struct dbg_info*)&dbg_info_pstreamOPputs_data;

/**** BEGIN ITERATOR BODIES for puts ****/

errcode pstreamOPputs_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 len;
    CLUREF c;
    CLUREF ps;
    CLUREF s;
    } *locals;
{
    locals->c.num = iv_1.num;
    enter_iter_body_proc(203);

  FB_LINE(203);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.ch = '\n';
    T_1_2.num = (locals->c.ch == T_1_1.ch)? true : false;
    if (T_1_2.num == true) {

  FB_LINE(204);
        {
        CLUREF T_2_1;
        T_2_1.num = locals->ps.vec->data[10];
        locals->err = streamOPputc(T_2_1, locals->c);
        if (locals->err != ERR_ok) goto ex_0;
        }

  FB_LINE(205);
        {
        locals->ps.vec->data[5]  = 0;
        }

  FB_LINE(206);
        {
        locals->ps.vec->data[9]  = 0;
        }
        }
    else {

  FB_LINE(207);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        CLUREF T_2_5;
        T_2_2.num = locals->ps.vec->data[11];
        T_2_1.num = T_2_2.num;
        if (T_2_2.num) {
            T_2_3.num = locals->ps.vec->data[9];
            T_2_4.num = locals->ps.vec->data[6];
            T_2_5.num = (T_2_3.num >= T_2_4.num)? true : false;
            T_2_1.num = T_2_5.num;
        }
        if (T_2_1.num == true) {

  FB_LINE(208);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals->ps.vec->data[10];
            T_3_2.ch = '\n';
            locals->err = streamOPputc(T_3_1, T_3_2);
            if (locals->err != ERR_ok) goto ex_0;
            }

  FB_LINE(209);
            {
            locals->ps.vec->data[9]  = 0;
            }
            }
            }/* end if */

  FB_LINE(211);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals->ps.vec->data[9];
        T_2_2.num = locals->ps.vec->data[6];
        T_2_3.num = (T_2_1.num < T_2_2.num)? true : false;
        if (T_2_3.num == true) {

  FB_LINE(212);
            {
            CLUREF T_3_1;
            T_3_1.num = locals->ps.vec->data[10];
            locals->err = streamOPputc(T_3_1, locals->c);
            if (locals->err != ERR_ok) goto ex_0;
            }

  FB_LINE(213);
            {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals->ps.vec->data[9];
            locals->err = intOPadd(T_3_1, CLU_1, &T_3_2);
            if (locals->err != ERR_ok) goto ex_0;
            locals->ps.vec->data[9]  = T_3_2.num;
            }
            }
            }/* end if */

  FB_LINE(215);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals->ps.vec->data[5];
        locals->err = intOPadd(T_2_1, CLU_1, &T_2_2);
        if (locals->err != ERR_ok) goto ex_0;
        locals->ps.vec->data[5]  = T_2_2.num;
        }
        }}/* end if */
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end pstreamOPputs_IB_1 */

/**** END ITERATOR BODIES for puts ****/

extern struct dbg_info* dbg_info_pstreamOPputsp;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPputsp_TRACE
int pstreamOPputsp_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPputsp_own_init = 0;

/**** BEGIN PROCEDURE putsp ****/

errcode pstreamOPputsp(ps, len)
CLUREF ps;
CLUREF len;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        CLUREF len;
        } locals;
    locals.ps.num = UNINIT;
    locals.len.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPputsp;
    locals.ps = ps;
    locals.len = len;
        if (pstreamOPputsp_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPputsp_own_init = 1;
    }
    enter_proc(220);

  LINE(221);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals.len.num == 0)? true : false;
    if (T_1_1.num == true) {

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

  LINE(223);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.ps.vec->data[5];
    locals.err = intOPadd(T_1_1, locals.len, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.ps.vec->data[5]  = T_1_2.num;
    }

  LINE(224);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    CLUREF T_1_5;
    CLUREF T_1_6;
    T_1_2.num = locals.ps.vec->data[11];
    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.ps.vec->data[9];
        T_1_5.num = locals.ps.vec->data[6];
        T_1_6.num = (T_1_4.num >= T_1_5.num)? true : false;
        T_1_1.num = T_1_6.num;
    }
    if (T_1_1.num == true) {

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

  LINE(226);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.ps.vec->data[9];
    locals.err = intOPadd(T_1_1, locals.len, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.ps.vec->data[9]  = T_1_2.num;
    }

  LINE(227);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    T_1_1.num = locals.ps.vec->data[9];
    T_1_2.num = locals.ps.vec->data[6];
    T_1_3.num = (T_1_1.num <= T_1_2.num)? true : false;
    if (T_1_3.num == true) {

  LINE(228);
        {
        CLUREF T_2_1;
        T_2_1.num = locals.ps.vec->data[10];
        locals.err = streamOPputspace(T_2_1, locals.len);
        if (locals.err != ERR_ok) goto ex_0;
        }

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

  LINE(231);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        T_1_1.num = locals.ps.vec->data[9];
        T_1_2.num = locals.ps.vec->data[6];
        T_1_3.num = (T_1_1.num > T_1_2.num)? true : false;
        if (T_1_3.num != true) { break; }

  LINE(232);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.ps.vec->data[10];
        T_2_2.ch = '\n';
        locals.err = streamOPputc(T_2_1, T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        }

  LINE(233);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.ps.vec->data[9];
        T_2_2.num = locals.ps.vec->data[6];
        locals.err = intOPsub(T_2_1, T_2_2, &T_2_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.ps.vec->data[9]  = T_2_3.num;
        }
        }
        end_while_1:;

  LINE(235);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.ps.vec->data[10];
    T_1_2.num = locals.ps.vec->data[9];
    locals.err = streamOPputspace(T_1_1, 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 putsp ****/

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;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPputsp_actual;
static Vlist0 vals_pstreamOPputsp = {0, 0};
static siglist0 sigs_pstreamOPputsp = {0, 0};
static Vlist4 locals_pstreamOPputsp = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "len", &int_ops}}
};
static Vlist0 popowns_pstreamOPputsp = {0, 0};
Slist0 tformals_pstreamOPputsp = {0, 0};
Slist0 opformals_pstreamOPputsp = {0, 0};
dbg_info_pstreamOPputsp_actual dbg_info_pstreamOPputsp_data = {0, 12, 
    "pstreamOPputsp", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPputsp, 2, 
    &vals_pstreamOPputsp, &sigs_pstreamOPputsp, &locals_pstreamOPputsp, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPputsp = (struct dbg_info*)&dbg_info_pstreamOPputsp_data;
extern struct dbg_info* dbg_info_pstreamOPget_indent;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPget_indent_TRACE
int pstreamOPget_indent_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPget_indent_own_init = 0;

/**** BEGIN PROCEDURE get_indent ****/

errcode pstreamOPget_indent(ps, ret_1)
CLUREF ps;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        } locals;
    locals.ps.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPget_indent;
    locals.ps = ps;
        if (pstreamOPget_indent_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPget_indent_own_init = 1;
    }
    enter_proc(238);

  LINE(239);
    {
    {
    CLUREF T_2_1;
    CLUREF T_2_2;
    T_2_1.num = locals.ps.vec->data[1];
    locals.err = arrayOPtop(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(240);
                {
                {
                ret_1->num = 0;
                }
                {signal (ERR_ok);}}
            }
            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 get_indent ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist3 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPget_indent_actual;
static Vlist1 vals_pstreamOPget_indent = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_pstreamOPget_indent = {0, 0};
static Vlist3 locals_pstreamOPget_indent = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops}}
};
static Vlist0 popowns_pstreamOPget_indent = {0, 0};
Slist0 tformals_pstreamOPget_indent = {0, 0};
Slist0 opformals_pstreamOPget_indent = {0, 0};
dbg_info_pstreamOPget_indent_actual dbg_info_pstreamOPget_indent_data = {0, 12, 
    "pstreamOPget_indent", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPget_indent, 1, 
    &vals_pstreamOPget_indent, &sigs_pstreamOPget_indent, &locals_pstreamOPget_indent, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPget_indent = (struct dbg_info*)&dbg_info_pstreamOPget_indent_data;
extern struct dbg_info* dbg_info_pstreamOPset_indent;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPset_indent_TRACE
int pstreamOPset_indent_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPset_indent_own_init = 0;

/**** BEGIN PROCEDURE set_indent ****/

errcode pstreamOPset_indent(ps, indent)
CLUREF ps;
CLUREF indent;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        CLUREF indent;
        } locals;
    locals.ps.num = UNINIT;
    locals.indent.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPset_indent;
    locals.ps = ps;
    locals.indent = indent;
        if (pstreamOPset_indent_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPset_indent_own_init = 1;
    }
    enter_proc(243);

  LINE(244);
    {
    CLUREF T_2_1;
    CLUREF T_2_2;
    T_2_1.num = locals.ps.vec->data[1];
    T_2_2.num = locals.ps.vec->data[3];
    locals.err = arrayOPstore(T_2_1, T_2_2, locals.indent);
    if (locals.err != ERR_ok) goto ex_1;
    }
        goto end_1;
        ex_1:
            if ((locals.err == ERR_bounds)) {
            }
            else {
                goto ex_0;
            }
        end_1:;
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE set_indent ****/

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;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPset_indent_actual;
static Vlist0 vals_pstreamOPset_indent = {0, 0};
static siglist0 sigs_pstreamOPset_indent = {0, 0};
static Vlist4 locals_pstreamOPset_indent = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "indent", &int_ops}}
};
static Vlist0 popowns_pstreamOPset_indent = {0, 0};
Slist0 tformals_pstreamOPset_indent = {0, 0};
Slist0 opformals_pstreamOPset_indent = {0, 0};
dbg_info_pstreamOPset_indent_actual dbg_info_pstreamOPset_indent_data = {0, 12, 
    "pstreamOPset_indent", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPset_indent, 2, 
    &vals_pstreamOPset_indent, &sigs_pstreamOPset_indent, &locals_pstreamOPset_indent, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPset_indent = (struct dbg_info*)&dbg_info_pstreamOPset_indent_data;
extern struct dbg_info* dbg_info_pstreamOPget_max_depth;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPget_max_depth_TRACE
int pstreamOPget_max_depth_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPget_max_depth_own_init = 0;

/**** BEGIN PROCEDURE get_max_depth ****/

errcode pstreamOPget_max_depth(ps, ret_1)
CLUREF ps;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        } locals;
    locals.ps.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPget_max_depth;
    locals.ps = ps;
        if (pstreamOPget_max_depth_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPget_max_depth_own_init = 1;
    }
    enter_proc(248);

  LINE(249);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps.vec->data[7];
    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_max_depth ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist3 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPget_max_depth_actual;
static Vlist1 vals_pstreamOPget_max_depth = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_pstreamOPget_max_depth = {0, 0};
static Vlist3 locals_pstreamOPget_max_depth = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops}}
};
static Vlist0 popowns_pstreamOPget_max_depth = {0, 0};
Slist0 tformals_pstreamOPget_max_depth = {0, 0};
Slist0 opformals_pstreamOPget_max_depth = {0, 0};
dbg_info_pstreamOPget_max_depth_actual dbg_info_pstreamOPget_max_depth_data = {0, 12, 
    "pstreamOPget_max_depth", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPget_max_depth, 1, 
    &vals_pstreamOPget_max_depth, &sigs_pstreamOPget_max_depth, &locals_pstreamOPget_max_depth, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPget_max_depth = (struct dbg_info*)&dbg_info_pstreamOPget_max_depth_data;
extern struct dbg_info* dbg_info_pstreamOPset_max_depth;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPset_max_depth_TRACE
int pstreamOPset_max_depth_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPset_max_depth_own_init = 0;

/**** BEGIN PROCEDURE set_max_depth ****/

errcode pstreamOPset_max_depth(ps, depth)
CLUREF ps;
CLUREF depth;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        CLUREF depth;
        } locals;
    locals.ps.num = UNINIT;
    locals.depth.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPset_max_depth;
    locals.ps = ps;
    locals.depth = depth;
        if (pstreamOPset_max_depth_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPset_max_depth_own_init = 1;
    }
    enter_proc(252);

  LINE(253);
    {
    locals.ps.vec->data[7]  = locals.depth.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 set_max_depth ****/

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;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPset_max_depth_actual;
static Vlist0 vals_pstreamOPset_max_depth = {0, 0};
static siglist0 sigs_pstreamOPset_max_depth = {0, 0};
static Vlist4 locals_pstreamOPset_max_depth = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "depth", &int_ops}}
};
static Vlist0 popowns_pstreamOPset_max_depth = {0, 0};
Slist0 tformals_pstreamOPset_max_depth = {0, 0};
Slist0 opformals_pstreamOPset_max_depth = {0, 0};
dbg_info_pstreamOPset_max_depth_actual dbg_info_pstreamOPset_max_depth_data = {0, 12, 
    "pstreamOPset_max_depth", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPset_max_depth, 2, 
    &vals_pstreamOPset_max_depth, &sigs_pstreamOPset_max_depth, &locals_pstreamOPset_max_depth, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPset_max_depth = (struct dbg_info*)&dbg_info_pstreamOPset_max_depth_data;
extern struct dbg_info* dbg_info_pstreamOPget_max_width;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPget_max_width_TRACE
int pstreamOPget_max_width_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPget_max_width_own_init = 0;

/**** BEGIN PROCEDURE get_max_width ****/

errcode pstreamOPget_max_width(ps, ret_1)
CLUREF ps;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        } locals;
    locals.ps.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPget_max_width;
    locals.ps = ps;
        if (pstreamOPget_max_width_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPget_max_width_own_init = 1;
    }
    enter_proc(256);

  LINE(257);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps.vec->data[8];
    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_max_width ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist3 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPget_max_width_actual;
static Vlist1 vals_pstreamOPget_max_width = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_pstreamOPget_max_width = {0, 0};
static Vlist3 locals_pstreamOPget_max_width = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops}}
};
static Vlist0 popowns_pstreamOPget_max_width = {0, 0};
Slist0 tformals_pstreamOPget_max_width = {0, 0};
Slist0 opformals_pstreamOPget_max_width = {0, 0};
dbg_info_pstreamOPget_max_width_actual dbg_info_pstreamOPget_max_width_data = {0, 12, 
    "pstreamOPget_max_width", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPget_max_width, 1, 
    &vals_pstreamOPget_max_width, &sigs_pstreamOPget_max_width, &locals_pstreamOPget_max_width, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPget_max_width = (struct dbg_info*)&dbg_info_pstreamOPget_max_width_data;
extern struct dbg_info* dbg_info_pstreamOPset_max_width;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPset_max_width_TRACE
int pstreamOPset_max_width_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPset_max_width_own_init = 0;

/**** BEGIN PROCEDURE set_max_width ****/

errcode pstreamOPset_max_width(ps, width)
CLUREF ps;
CLUREF width;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        CLUREF width;
        } locals;
    locals.ps.num = UNINIT;
    locals.width.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPset_max_width;
    locals.ps = ps;
    locals.width = width;
        if (pstreamOPset_max_width_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPset_max_width_own_init = 1;
    }
    enter_proc(260);

  LINE(261);
    {
    locals.ps.vec->data[8]  = locals.width.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 set_max_width ****/

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;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPset_max_width_actual;
static Vlist0 vals_pstreamOPset_max_width = {0, 0};
static siglist0 sigs_pstreamOPset_max_width = {0, 0};
static Vlist4 locals_pstreamOPset_max_width = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "width", &int_ops}}
};
static Vlist0 popowns_pstreamOPset_max_width = {0, 0};
Slist0 tformals_pstreamOPset_max_width = {0, 0};
Slist0 opformals_pstreamOPset_max_width = {0, 0};
dbg_info_pstreamOPset_max_width_actual dbg_info_pstreamOPset_max_width_data = {0, 12, 
    "pstreamOPset_max_width", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPset_max_width, 2, 
    &vals_pstreamOPset_max_width, &sigs_pstreamOPset_max_width, &locals_pstreamOPset_max_width, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPset_max_width = (struct dbg_info*)&dbg_info_pstreamOPset_max_width_data;
extern struct dbg_info* dbg_info_pstreamOPget_flat;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPget_flat_TRACE
int pstreamOPget_flat_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPget_flat_own_init = 0;

/**** BEGIN PROCEDURE get_flat ****/

errcode pstreamOPget_flat(ps, ret_1)
CLUREF ps;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        } locals;
    locals.ps.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPget_flat;
    locals.ps = ps;
        if (pstreamOPget_flat_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPget_flat_own_init = 1;
    }
    enter_proc(264);

  LINE(265);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps.vec->data[4];
    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_flat ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist3 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPget_flat_actual;
static Vlist1 vals_pstreamOPget_flat = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_pstreamOPget_flat = {0, 0};
static Vlist3 locals_pstreamOPget_flat = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops}}
};
static Vlist0 popowns_pstreamOPget_flat = {0, 0};
Slist0 tformals_pstreamOPget_flat = {0, 0};
Slist0 opformals_pstreamOPget_flat = {0, 0};
dbg_info_pstreamOPget_flat_actual dbg_info_pstreamOPget_flat_data = {0, 12, 
    "pstreamOPget_flat", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPget_flat, 1, 
    &vals_pstreamOPget_flat, &sigs_pstreamOPget_flat, &locals_pstreamOPget_flat, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPget_flat = (struct dbg_info*)&dbg_info_pstreamOPget_flat_data;
extern struct dbg_info* dbg_info_pstreamOPset_flat;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPset_flat_TRACE
int pstreamOPset_flat_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPset_flat_own_init = 0;

/**** BEGIN PROCEDURE set_flat ****/

errcode pstreamOPset_flat(ps, flat)
CLUREF ps;
CLUREF flat;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        CLUREF flat;
        } locals;
    locals.ps.num = UNINIT;
    locals.flat.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPset_flat;
    locals.ps = ps;
    locals.flat = flat;
        if (pstreamOPset_flat_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPset_flat_own_init = 1;
    }
    enter_proc(268);

  LINE(269);
    {
    locals.ps.vec->data[4]  = locals.flat.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 set_flat ****/

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;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPset_flat_actual;
static Vlist0 vals_pstreamOPset_flat = {0, 0};
static siglist0 sigs_pstreamOPset_flat = {0, 0};
static Vlist4 locals_pstreamOPset_flat = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "flat", &bool_ops}}
};
static Vlist0 popowns_pstreamOPset_flat = {0, 0};
Slist0 tformals_pstreamOPset_flat = {0, 0};
Slist0 opformals_pstreamOPset_flat = {0, 0};
dbg_info_pstreamOPset_flat_actual dbg_info_pstreamOPset_flat_data = {0, 12, 
    "pstreamOPset_flat", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPset_flat, 2, 
    &vals_pstreamOPset_flat, &sigs_pstreamOPset_flat, &locals_pstreamOPset_flat, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPset_flat = (struct dbg_info*)&dbg_info_pstreamOPset_flat_data;
extern struct dbg_info* dbg_info_pstreamOPget_wrap;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPget_wrap_TRACE
int pstreamOPget_wrap_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPget_wrap_own_init = 0;

/**** BEGIN PROCEDURE get_wrap ****/

errcode pstreamOPget_wrap(ps, ret_1)
CLUREF ps;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        } locals;
    locals.ps.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPget_wrap;
    locals.ps = ps;
        if (pstreamOPget_wrap_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPget_wrap_own_init = 1;
    }
    enter_proc(272);

  LINE(273);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps.vec->data[11];
    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_wrap ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist3 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPget_wrap_actual;
static Vlist1 vals_pstreamOPget_wrap = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_pstreamOPget_wrap = {0, 0};
static Vlist3 locals_pstreamOPget_wrap = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops}}
};
static Vlist0 popowns_pstreamOPget_wrap = {0, 0};
Slist0 tformals_pstreamOPget_wrap = {0, 0};
Slist0 opformals_pstreamOPget_wrap = {0, 0};
dbg_info_pstreamOPget_wrap_actual dbg_info_pstreamOPget_wrap_data = {0, 12, 
    "pstreamOPget_wrap", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPget_wrap, 1, 
    &vals_pstreamOPget_wrap, &sigs_pstreamOPget_wrap, &locals_pstreamOPget_wrap, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPget_wrap = (struct dbg_info*)&dbg_info_pstreamOPget_wrap_data;
extern struct dbg_info* dbg_info_pstreamOPset_wrap;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPset_wrap_TRACE
int pstreamOPset_wrap_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPset_wrap_own_init = 0;

/**** BEGIN PROCEDURE set_wrap ****/

errcode pstreamOPset_wrap(ps, wrap)
CLUREF ps;
CLUREF wrap;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        CLUREF wrap;
        } locals;
    locals.ps.num = UNINIT;
    locals.wrap.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPset_wrap;
    locals.ps = ps;
    locals.wrap = wrap;
        if (pstreamOPset_wrap_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPset_wrap_own_init = 1;
    }
    enter_proc(276);

  LINE(277);
    {
    locals.ps.vec->data[11]  = locals.wrap.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 set_wrap ****/

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;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPset_wrap_actual;
static Vlist0 vals_pstreamOPset_wrap = {0, 0};
static siglist0 sigs_pstreamOPset_wrap = {0, 0};
static Vlist4 locals_pstreamOPset_wrap = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "wrap", &bool_ops}}
};
static Vlist0 popowns_pstreamOPset_wrap = {0, 0};
Slist0 tformals_pstreamOPset_wrap = {0, 0};
Slist0 opformals_pstreamOPset_wrap = {0, 0};
dbg_info_pstreamOPset_wrap_actual dbg_info_pstreamOPset_wrap_data = {0, 12, 
    "pstreamOPset_wrap", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPset_wrap, 2, 
    &vals_pstreamOPset_wrap, &sigs_pstreamOPset_wrap, &locals_pstreamOPset_wrap, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPset_wrap = (struct dbg_info*)&dbg_info_pstreamOPset_wrap_data;
extern struct dbg_info* dbg_info_pstreamOPget_line_length;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPget_line_length_TRACE
int pstreamOPget_line_length_TRACE;
extern OWN_req stream_ownreqs;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPget_line_length_own_init = 0;

/**** BEGIN PROCEDURE get_line_length ****/

errcode pstreamOPget_line_length(ps, ret_1)
CLUREF ps;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        } locals;
    locals.ps.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPget_line_length;
    locals.ps = ps;
        if (pstreamOPget_line_length_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPget_line_length_own_init = 1;
    }
    enter_proc(280);

  LINE(281);
    {
    {
    CLUREF T_2_1;
    CLUREF T_2_2;
    T_2_1.num = locals.ps.vec->data[10];
    locals.err = streamOPget_line_length(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_no_limit) {signal(ERR_no_limit);}
        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 get_line_length ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist3 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPget_line_length_actual;
static Vlist1 vals_pstreamOPget_line_length = {0, 1, { {0, 2, "", &int_ops}}
};
static sig_desc0 sig_pstreamOPget_line_length_1 = {0, 3, "no_limit", {0, 0
}};
static siglist1 sigs_pstreamOPget_line_length = {0, 1, (sig_desc*)&sig_pstreamOPget_line_length_1};
static Vlist3 locals_pstreamOPget_line_length = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops}}
};
static Vlist0 popowns_pstreamOPget_line_length = {0, 0};
Slist0 tformals_pstreamOPget_line_length = {0, 0};
Slist0 opformals_pstreamOPget_line_length = {0, 0};
dbg_info_pstreamOPget_line_length_actual dbg_info_pstreamOPget_line_length_data = {0, 12, 
    "pstreamOPget_line_length", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPget_line_length, 1, 
    &vals_pstreamOPget_line_length, &sigs_pstreamOPget_line_length, &locals_pstreamOPget_line_length, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPget_line_length = (struct dbg_info*)&dbg_info_pstreamOPget_line_length_data;
extern struct dbg_info* dbg_info_pstreamOPget_page_length;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPget_page_length_TRACE
int pstreamOPget_page_length_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPget_page_length_own_init = 0;

/**** BEGIN PROCEDURE get_page_length ****/

errcode pstreamOPget_page_length(ps, ret_1)
CLUREF ps;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        } locals;
    locals.ps.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPget_page_length;
    locals.ps = ps;
        if (pstreamOPget_page_length_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPget_page_length_own_init = 1;
    }
    enter_proc(285);

  LINE(286);
    {
    {
    CLUREF T_2_1;
    CLUREF T_2_2;
    T_2_1.num = locals.ps.vec->data[10];
    locals.err = streamOPget_page_length(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_no_limit) {signal(ERR_no_limit);}
        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 get_page_length ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist3 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPget_page_length_actual;
static Vlist1 vals_pstreamOPget_page_length = {0, 1, { {0, 2, "", &int_ops}}
};
static sig_desc0 sig_pstreamOPget_page_length_1 = {0, 3, "no_limit", {0, 0
}};
static siglist1 sigs_pstreamOPget_page_length = {0, 1, (sig_desc*)&sig_pstreamOPget_page_length_1};
static Vlist3 locals_pstreamOPget_page_length = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops}}
};
static Vlist0 popowns_pstreamOPget_page_length = {0, 0};
Slist0 tformals_pstreamOPget_page_length = {0, 0};
Slist0 opformals_pstreamOPget_page_length = {0, 0};
dbg_info_pstreamOPget_page_length_actual dbg_info_pstreamOPget_page_length_data = {0, 12, 
    "pstreamOPget_page_length", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPget_page_length, 1, 
    &vals_pstreamOPget_page_length, &sigs_pstreamOPget_page_length, &locals_pstreamOPget_page_length, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPget_page_length = (struct dbg_info*)&dbg_info_pstreamOPget_page_length_data;
extern struct dbg_info* dbg_info_pstreamOPequal;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPequal_TRACE
int pstreamOPequal_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPequal_own_init = 0;

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

errcode pstreamOPequal(x, y, ret_1)
CLUREF x;
CLUREF y;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF x;
        CLUREF y;
        } locals;
    locals.x.num = UNINIT;
    locals.y.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPequal;
    locals.x = x;
    locals.y = y;
        if (pstreamOPequal_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPequal_own_init = 1;
    }
    enter_proc(290);

  LINE(291);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = (locals.x.num == locals.y.num)? true : false;
    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 equal ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPequal_actual;
static Vlist1 vals_pstreamOPequal = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_pstreamOPequal = {0, 0};
static Vlist4 locals_pstreamOPequal = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "x", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "y", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops}}
};
static Vlist0 popowns_pstreamOPequal = {0, 0};
Slist0 tformals_pstreamOPequal = {0, 0};
Slist0 opformals_pstreamOPequal = {0, 0};
dbg_info_pstreamOPequal_actual dbg_info_pstreamOPequal_data = {0, 12, 
    "pstreamOPequal", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPequal, 2, 
    &vals_pstreamOPequal, &sigs_pstreamOPequal, &locals_pstreamOPequal, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPequal = (struct dbg_info*)&dbg_info_pstreamOPequal_data;
extern struct dbg_info* dbg_info_pstreamOPreset;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPreset_TRACE
int pstreamOPreset_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPreset_own_init = 0;

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

errcode pstreamOPreset(ps)
CLUREF ps;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps;
        } locals;
    locals.ps.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPreset;
    locals.ps = ps;
        if (pstreamOPreset_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPreset_own_init = 1;
    }
    enter_proc(294);

  LINE(295);
    {
    locals.ps.vec->data[5]  = 0;
    }

  LINE(296);
    {
    locals.ps.vec->data[9]  = 0;
    }

  LINE(297);
    {
    locals.ps.vec->data[0]  = false;
    }

  LINE(298);
    {
    locals.ps.vec->data[3]  = 0;
    }

  LINE(299);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps.vec->data[1];
    locals.err = arrayOPtrim(T_1_1, CLU_1, CLU_0);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(300);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps.vec->data[2];
    locals.err = arrayOPtrim(T_1_1, CLU_1, CLU_0);
    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 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;
    Vlist3 *locals;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPreset_actual;
static Vlist0 vals_pstreamOPreset = {0, 0};
static siglist0 sigs_pstreamOPreset = {0, 0};
static Vlist3 locals_pstreamOPreset = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops}}
};
static Vlist0 popowns_pstreamOPreset = {0, 0};
Slist0 tformals_pstreamOPreset = {0, 0};
Slist0 opformals_pstreamOPreset = {0, 0};
dbg_info_pstreamOPreset_actual dbg_info_pstreamOPreset_data = {0, 12, 
    "pstreamOPreset", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPreset, 1, 
    &vals_pstreamOPreset, &sigs_pstreamOPreset, &locals_pstreamOPreset, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPreset = (struct dbg_info*)&dbg_info_pstreamOPreset_data;
extern struct dbg_info* dbg_info_pstreamOPprint;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPprint_TRACE
int pstreamOPprint_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPprint_own_init = 0;

/**** BEGIN PROCEDURE print ****/

errcode pstreamOPprint(ps1, ps2)
CLUREF ps1;
CLUREF ps2;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ps1;
        CLUREF ps2;
        } locals;
    locals.ps1.num = UNINIT;
    locals.ps2.num = UNINIT;
    locals.DBG_INFO = dbg_info_pstreamOPprint;
    locals.ps1 = ps1;
    locals.ps2 = ps2;
        if (pstreamOPprint_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPprint_own_init = 1;
    }
    enter_proc(303);

  LINE(304);
    {
    CLUREF T_1_1;
    locals.err = pstreamOPtext(locals.ps2, STR_pstream_133, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(305);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps1.vec->data[7];
    locals.err = intOPprint(T_1_1, locals.ps2);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(306);
    {
    CLUREF T_1_1;
    locals.err = pstreamOPtext(locals.ps2, STR_d_040, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(307);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps1.vec->data[8];
    locals.err = intOPprint(T_1_1, locals.ps2);
    if (locals.err != ERR_ok) goto ex_0;
    }

  LINE(308);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps1.vec->data[4];
    if (T_1_1.num == true) {

  LINE(309);
        {
        CLUREF T_2_1;
        locals.err = pstreamOPtext(locals.ps2, STR_w_040f_040, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        }
        }
    else {

  LINE(310);
        {
        CLUREF T_2_1;
        locals.err = pstreamOPtext(locals.ps2, STR_w_040i_040, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        }
        }}/* end if */

  LINE(312);
    {
    CLUREF T_1_1;
    T_1_1.num = locals.ps1.vec->data[11];
    if (T_1_1.num == true) {

  LINE(313);
        {
        CLUREF T_2_1;
        locals.err = pstreamOPtext(locals.ps2, STR_m_040, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        }
        }
    else {

  LINE(314);
        {
        CLUREF T_2_1;
        locals.err = pstreamOPtext(locals.ps2, STR_s_040, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        }
        }}/* end if */

  LINE(316);
    {
    CLUREF T_2_1;
    CLUREF T_2_2;
    T_2_1.num = locals.ps1.vec->data[10];
    locals.err = streamOPget_name(T_2_1, &T_2_2);
    if (locals.err != ERR_ok) goto ex_1;
    locals.err = file_nameOPprint(T_2_2, locals.ps2);
    if (locals.err != ERR_ok) goto ex_1;
    }
        goto end_1;
        ex_1:
            if ((locals.err == ERR_not_possible)) {

  LINE(317);
                {
                CLUREF T_2_1;
                locals.err = pstreamOPtext(locals.ps2, STR__050internal_051, &T_2_1);
                if (locals.err != ERR_ok) goto ex_0;
                }
            }
            else {
                goto ex_0;
            }
        end_1:;

  LINE(318);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.ch = ']';
    locals.err = pstreamOPtextc(locals.ps2, T_1_1, &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 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;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPprint_actual;
static Vlist0 vals_pstreamOPprint = {0, 0};
static siglist0 sigs_pstreamOPprint = {0, 0};
static Vlist4 locals_pstreamOPprint = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ps1", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "ps2", &pstream_ops}}
};
static Vlist0 popowns_pstreamOPprint = {0, 0};
Slist0 tformals_pstreamOPprint = {0, 0};
Slist0 opformals_pstreamOPprint = {0, 0};
dbg_info_pstreamOPprint_actual dbg_info_pstreamOPprint_data = {0, 12, 
    "pstreamOPprint", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPprint, 2, 
    &vals_pstreamOPprint, &sigs_pstreamOPprint, &locals_pstreamOPprint, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPprint = (struct dbg_info*)&dbg_info_pstreamOPprint_data;
extern struct dbg_info* dbg_info_pstreamOPdebug_print;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG pstreamOPdebug_print_TRACE
int pstreamOPdebug_print_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
struct OPS  *record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops;
static int pstreamOPdebug_print_own_init = 0;

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

errcode pstreamOPdebug_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_pstreamOPdebug_print;
    locals._rep = _rep;
    locals.ps = ps;
        if (pstreamOPdebug_print_own_init == 0) {
        if (pstream_own_init == 0) {
            locals.err = pstream_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        pstreamOPdebug_print_own_init = 1;
    }
    enter_proc(1);

  LINE(2);
    {
    locals.err = pstreamOPprint(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;
    Vlist32 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_pstreamOPdebug_print_actual;
static Vlist0 vals_pstreamOPdebug_print = {0, 0};
static siglist0 sigs_pstreamOPdebug_print = {0, 0};
static Vlist4 locals_pstreamOPdebug_print = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "_rep", &record_abort_aindent_awidth_depth_flat_hpos_llen_max_depth_max_width_rhpos_stream_wrap_ops},  {0, 2, "ps", &pstream_ops}}
};
static Vlist0 popowns_pstreamOPdebug_print = {0, 0};
Slist0 tformals_pstreamOPdebug_print = {0, 0};
Slist0 opformals_pstreamOPdebug_print = {0, 0};
dbg_info_pstreamOPdebug_print_actual dbg_info_pstreamOPdebug_print_data = {0, 12, 
    "pstreamOPdebug_print", "/common/pub/dcurtis-temp/pclu/lib/clu/pstream.clu", 0, 0, (int)pstreamOPdebug_print, 2, 
    &vals_pstreamOPdebug_print, &sigs_pstreamOPdebug_print, &locals_pstreamOPdebug_print, &owns_pstream, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_pstreamOPdebug_print = (struct dbg_info*)&dbg_info_pstreamOPdebug_print_data;
typedef struct{
    int count;
    OWNPTR type_owns;
    OWNPTR op_owns;
    struct OP_ENTRY entry[28];
} pstream_OPS;

CLU_proc pstream_oe_create = {{0,0,0,0}, pstreamOPcreate, 0};
CLU_proc pstream_oe_equal = {{0,0,0,0}, pstreamOPequal, 0};
CLU_proc pstream_oe_get_depth = {{0,0,0,0}, pstreamOPget_depth, 0};
CLU_proc pstream_oe_get_flat = {{0,0,0,0}, pstreamOPget_flat, 0};
CLU_proc pstream_oe_get_hpos = {{0,0,0,0}, pstreamOPget_hpos, 0};
CLU_proc pstream_oe_get_indent = {{0,0,0,0}, pstreamOPget_indent, 0};
CLU_proc pstream_oe_get_line_length = {{0,0,0,0}, pstreamOPget_line_length, 0};
CLU_proc pstream_oe_get_max_depth = {{0,0,0,0}, pstreamOPget_max_depth, 0};
CLU_proc pstream_oe_get_max_width = {{0,0,0,0}, pstreamOPget_max_width, 0};
CLU_proc pstream_oe_get_page_length = {{0,0,0,0}, pstreamOPget_page_length, 0};
CLU_proc pstream_oe_get_wrap = {{0,0,0,0}, pstreamOPget_wrap, 0};
CLU_proc pstream_oe_pause = {{0,0,0,0}, pstreamOPpause, 0};
CLU_proc pstream_oe_primary_output = {{0,0,0,0}, pstreamOPprimary_output, 0};
CLU_proc pstream_oe_print = {{0,0,0,0}, pstreamOPprint, 0};
CLU_proc pstream_oe_putleft = {{0,0,0,0}, pstreamOPputleft, 0};
CLU_proc pstream_oe_putright = {{0,0,0,0}, pstreamOPputright, 0};
CLU_proc pstream_oe_putspace = {{0,0,0,0}, pstreamOPputspace, 0};
CLU_proc pstream_oe_reset = {{0,0,0,0}, pstreamOPreset, 0};
CLU_proc pstream_oe_set_flat = {{0,0,0,0}, pstreamOPset_flat, 0};
CLU_proc pstream_oe_set_indent = {{0,0,0,0}, pstreamOPset_indent, 0};
CLU_proc pstream_oe_set_max_depth = {{0,0,0,0}, pstreamOPset_max_depth, 0};
CLU_proc pstream_oe_set_max_width = {{0,0,0,0}, pstreamOPset_max_width, 0};
CLU_proc pstream_oe_set_wrap = {{0,0,0,0}, pstreamOPset_wrap, 0};
CLU_proc pstream_oe_start = {{0,0,0,0}, pstreamOPstart, 0};
CLU_proc pstream_oe_stop = {{0,0,0,0}, pstreamOPstop, 0};
CLU_proc pstream_oe_text = {{0,0,0,0}, pstreamOPtext, 0};
CLU_proc pstream_oe_textc = {{0,0,0,0}, pstreamOPtextc, 0};
CLU_proc pstream_oe_debug_print = {{0,0,0,0}, pstreamOPdebug_print, 0};

pstream_OPS pstream_ops_actual = {28, (OWNPTR)&pstream_own_init, (OWNPTR)&pstream_own_init, {
    {&pstream_oe_create, "create"},
    {&pstream_oe_equal, "equal"},
    {&pstream_oe_get_depth, "get_depth"},
    {&pstream_oe_get_flat, "get_flat"},
    {&pstream_oe_get_hpos, "get_hpos"},
    {&pstream_oe_get_indent, "get_indent"},
    {&pstream_oe_get_line_length, "get_line_length"},
    {&pstream_oe_get_max_depth, "get_max_depth"},
    {&pstream_oe_get_max_width, "get_max_width"},
    {&pstream_oe_get_page_length, "get_page_length"},
    {&pstream_oe_get_wrap, "get_wrap"},
    {&pstream_oe_pause, "pause"},
    {&pstream_oe_primary_output, "primary_output"},
    {&pstream_oe_print, "print"},
    {&pstream_oe_putleft, "putleft"},
    {&pstream_oe_putright, "putright"},
    {&pstream_oe_putspace, "putspace"},
    {&pstream_oe_reset, "reset"},
    {&pstream_oe_set_flat, "set_flat"},
    {&pstream_oe_set_indent, "set_indent"},
    {&pstream_oe_set_max_depth, "set_max_depth"},
    {&pstream_oe_set_max_width, "set_max_width"},
    {&pstream_oe_set_wrap, "set_wrap"},
    {&pstream_oe_start, "start"},
    {&pstream_oe_stop, "stop"},
    {&pstream_oe_text, "text"},
    {&pstream_oe_textc, "textc"},
    {&pstream_oe_debug_print, "debug_print"}}};

struct OPS *pstream_ops = (struct OPS *)&pstream_ops_actual;

/**** END CLUSTER pstream ****/