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

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


/**** BEGIN CLUSTER date ****/

extern errcode intOPlt();
extern errcode intOPgt();
extern errcode structOPget_1();
extern errcode structOPget_4();
extern errcode structOPget_6();
extern errcode structOPget_2();
extern errcode structOPget_3();
extern errcode structOPget_5();
extern errcode stringOPconcat();
extern errcode dateOPunparse_date();
extern errcode dateOPunparse_time();
extern errcode intOPunparse();
extern errcode sequenceOPfetch();
extern errcode structOPequal();
extern errcode boolOPnot();
extern errcode intOPequal();
extern errcode intOPle();
extern errcode dateOPlt();
extern errcode dateOPle();
extern errcode pstreamOPtext();
extern errcode dateOPunparse();
extern errcode intOPencode();
extern errcode dateOPcreate();
extern errcode intOPdecode();
extern errcode structOP_gcd();
extern errcode dateOPprint();
extern OWN_req gcd_tab_ownreqs;
extern struct OPS *gcd_tab_ops;
extern struct OPS *int_ops;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
extern struct REQS *sequence_of_t_reqs;
extern struct OPS *string_ops;
extern OWN_req sequence_ownreqs;
extern struct OPS *sequence_ops;
struct OPS *sequence_of_string_table;
struct OPS *sequence_of_string_ops;
struct OPS *sequence_of_string_ops;
OWNPTR sequence_of_string_owns;
CLUREF STR__040;
CLUREF STR_January;
CLUREF STR_February;
CLUREF STR_March;
CLUREF STR_April;
CLUREF STR_May;
CLUREF STR_June;
CLUREF STR_July;
CLUREF STR_August;
CLUREF STR_September;
CLUREF STR_October;
CLUREF STR_November;
CLUREF STR_December;
CLUREF STR_0;
CLUREF STR__072;
CLUREF STR_bad_040format;
static int date_own_init = 0;
OWN_req date_ownreqs = {0,0};
errcode date_own_init_proc()
{
struct {
    errcode err;
    } locals;
    enter_own_init_proc();
        if (date_own_init == 0) {
        add_selector_info("day", 0, int_ops); 
        add_selector_info("hour", 1, int_ops); 
        add_selector_info("minute", 2, int_ops); 
        add_selector_info("month", 3, int_ops); 
        add_selector_info("second", 4, int_ops); 
        add_selector_info("year", 5, int_ops); 
        find_selector_ops("struct", 6, &(struct_day_hour_minute_month_second_year_ops));
        add_parm_info_type(0, string_ops, sequence_of_t_reqs);
        find_type_instance(sequence_ops, 1, &sequence_ownreqs, &(sequence_of_string_ops));
        stringOPcons(" ", CLU_1, CLU_1, &STR__040);
        stringOPcons("January", CLU_1, CLU_7, &STR_January);
        stringOPcons("February", CLU_1, CLU_8, &STR_February);
        stringOPcons("March", CLU_1, CLU_5, &STR_March);
        stringOPcons("April", CLU_1, CLU_5, &STR_April);
        stringOPcons("May", CLU_1, CLU_3, &STR_May);
        stringOPcons("June", CLU_1, CLU_4, &STR_June);
        stringOPcons("July", CLU_1, CLU_4, &STR_July);
        stringOPcons("August", CLU_1, CLU_6, &STR_August);
        stringOPcons("September", CLU_1, CLU_9, &STR_September);
        stringOPcons("October", CLU_1, CLU_7, &STR_October);
        stringOPcons("November", CLU_1, CLU_8, &STR_November);
        stringOPcons("December", CLU_1, CLU_8, &STR_December);
        stringOPcons("0", CLU_1, CLU_1, &STR_0);
        stringOPcons(":", CLU_1, CLU_1, &STR__072);
        stringOPcons("bad format", CLU_1, CLU_10, &STR_bad_040format);
        date_own_init = 1;
        {signal(ERR_ok);}
    ex_0: pclu_unhandled(locals.err); {signal(ERR_failure);}
        }
    }

extern struct dbg_info* dbg_info_dateOPcreate;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPcreate_TRACE
int dateOPcreate_TRACE;
static Vlist24 owns_date = {0, 24,{ {0, 2, "date_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
, {0, 2, "dateOPcreate_init", &int_ops}
}
};
extern OWN_req int_ownreqs;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOPcreate_own_init = 0;

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

errcode dateOPcreate(day, month, year, hour, minute, second, ret_1)
CLUREF day;
CLUREF month;
CLUREF year;
CLUREF hour;
CLUREF minute;
CLUREF second;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF day;
        CLUREF month;
        CLUREF year;
        CLUREF hour;
        CLUREF minute;
        CLUREF second;
        } locals;
    locals.day.num = UNINIT;
    locals.month.num = UNINIT;
    locals.year.num = UNINIT;
    locals.hour.num = UNINIT;
    locals.minute.num = UNINIT;
    locals.second.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPcreate;
    locals.day = day;
    locals.month = month;
    locals.year = year;
    locals.hour = hour;
    locals.minute = minute;
    locals.second = second;
        if (dateOPcreate_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPcreate_own_init = 1;
    }
    enter_proc(28);

  LINE(30);
    {
    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;
    CLUREF T_1_11;
    CLUREF T_1_12;
    CLUREF T_1_13;
    CLUREF T_1_14;
    CLUREF T_1_15;
    CLUREF T_1_16;
    CLUREF T_1_17;
    CLUREF T_1_18;
    CLUREF T_1_19;
    CLUREF T_1_20;
    CLUREF T_1_21;
    CLUREF T_1_22;
    CLUREF T_1_23;
    T_1_11.num = (locals.day.num < 1)? true : false;
    T_1_10.num = T_1_11.num;
    if (!T_1_11.num) {
        T_1_12.num = (locals.day.num > 31)? true : false;
        T_1_10.num = T_1_12.num;
    }
    T_1_9.num = T_1_10.num;
    if (!T_1_10.num) {
        T_1_13.num = (locals.month.num < 1)? true : false;
        T_1_9.num = T_1_13.num;
    }
    T_1_8.num = T_1_9.num;
    if (!T_1_9.num) {
        T_1_14.num = (locals.month.num > 12)? true : false;
        T_1_8.num = T_1_14.num;
    }
    T_1_7.num = T_1_8.num;
    if (!T_1_8.num) {
        T_1_15.num = (locals.year.num < 1)? true : false;
        T_1_7.num = T_1_15.num;
    }
    T_1_6.num = T_1_7.num;
    if (!T_1_7.num) {
        T_1_16.num = (locals.hour.num < 0)? true : false;
        T_1_6.num = T_1_16.num;
    }
    T_1_5.num = T_1_6.num;
    if (!T_1_6.num) {
        T_1_17.num = (locals.hour.num > 23)? true : false;
        T_1_5.num = T_1_17.num;
    }
    T_1_4.num = T_1_5.num;
    if (!T_1_5.num) {
        T_1_18.num = (locals.minute.num < 0)? true : false;
        T_1_4.num = T_1_18.num;
    }
    T_1_3.num = T_1_4.num;
    if (!T_1_4.num) {
        T_1_19.num = 59;
        T_1_20.num = (locals.minute.num > T_1_19.num)? true : false;
        T_1_3.num = T_1_20.num;
    }
    T_1_2.num = T_1_3.num;
    if (!T_1_3.num) {
        T_1_21.num = (locals.second.num < 0)? true : false;
        T_1_2.num = T_1_21.num;
    }
    T_1_1.num = T_1_2.num;
    if (!T_1_2.num) {
        T_1_22.num = 59;
        T_1_23.num = (locals.second.num > T_1_22.num)? true : false;
        T_1_1.num = T_1_23.num;
    }
    if (T_1_1.num == true) {

  LINE(36);
        {
        {signal (ERR_bad_format);}}
        }
        }/* end if */

  LINE(37);
    {
    {
    CLUREF T_1_1;
    RecordAlloc(6, T_1_1);
    T_1_1.vec->data[0]  = locals.day.num;
    T_1_1.vec->data[3]  = locals.month.num;
    T_1_1.vec->data[5]  = locals.year.num;
    T_1_1.vec->data[1]  = locals.hour.num;
    T_1_1.vec->data[2]  = locals.minute.num;
    T_1_1.vec->data[4]  = locals.second.num;
    ret_1->num = T_1_1.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

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

extern struct OPS *struct_day_hour_minute_month_second_year_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;
    Vlist8 *locals;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPcreate_actual;
static Vlist1 vals_dateOPcreate = {0, 1, { {0, 2, "", &struct_day_hour_minute_month_second_year_ops}}
};
static sig_desc0 sig_dateOPcreate_1 = {0, 3, "bad_format", {0, 0
}};
static siglist1 sigs_dateOPcreate = {0, 1, (sig_desc*)&sig_dateOPcreate_1};
static Vlist8 locals_dateOPcreate = {0, 8,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "day", &int_ops},  {0, 2, "month", &int_ops},  {0, 2, "year", &int_ops},  {0, 2, "hour", &int_ops},  {0, 2, "minute", &int_ops},  {0, 2, "second", &int_ops}}
};
static Vlist0 popowns_dateOPcreate = {0, 0};
Slist0 tformals_dateOPcreate = {0, 0};
Slist0 opformals_dateOPcreate = {0, 0};
dbg_info_dateOPcreate_actual dbg_info_dateOPcreate_data = {0, 12, 
    "dateOPcreate", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPcreate, 6, 
    &vals_dateOPcreate, &sigs_dateOPcreate, &locals_dateOPcreate, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPcreate = (struct dbg_info*)&dbg_info_dateOPcreate_data;
extern struct dbg_info* dbg_info_dateOPget_day;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPget_day_TRACE
int dateOPget_day_TRACE;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOPget_day_own_init = 0;

/**** BEGIN PROCEDURE get_day ****/

errcode dateOPget_day(d, ret_1)
CLUREF d;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d;
        } locals;
    locals.d.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPget_day;
    locals.d = d;
        if (dateOPget_day_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPget_day_own_init = 1;
    }
    enter_proc(41);

  LINE(42);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.d.vec->data[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 get_day ****/

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;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPget_day_actual;
static Vlist1 vals_dateOPget_day = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_dateOPget_day = {0, 0};
static Vlist3 locals_dateOPget_day = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d", &struct_day_hour_minute_month_second_year_ops}}
};
static Vlist0 popowns_dateOPget_day = {0, 0};
Slist0 tformals_dateOPget_day = {0, 0};
Slist0 opformals_dateOPget_day = {0, 0};
dbg_info_dateOPget_day_actual dbg_info_dateOPget_day_data = {0, 12, 
    "dateOPget_day", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPget_day, 1, 
    &vals_dateOPget_day, &sigs_dateOPget_day, &locals_dateOPget_day, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPget_day = (struct dbg_info*)&dbg_info_dateOPget_day_data;
extern struct dbg_info* dbg_info_dateOPget_month;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPget_month_TRACE
int dateOPget_month_TRACE;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOPget_month_own_init = 0;

/**** BEGIN PROCEDURE get_month ****/

errcode dateOPget_month(d, ret_1)
CLUREF d;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d;
        } locals;
    locals.d.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPget_month;
    locals.d = d;
        if (dateOPget_month_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPget_month_own_init = 1;
    }
    enter_proc(45);

  LINE(46);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.d.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_month ****/

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;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPget_month_actual;
static Vlist1 vals_dateOPget_month = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_dateOPget_month = {0, 0};
static Vlist3 locals_dateOPget_month = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d", &struct_day_hour_minute_month_second_year_ops}}
};
static Vlist0 popowns_dateOPget_month = {0, 0};
Slist0 tformals_dateOPget_month = {0, 0};
Slist0 opformals_dateOPget_month = {0, 0};
dbg_info_dateOPget_month_actual dbg_info_dateOPget_month_data = {0, 12, 
    "dateOPget_month", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPget_month, 1, 
    &vals_dateOPget_month, &sigs_dateOPget_month, &locals_dateOPget_month, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPget_month = (struct dbg_info*)&dbg_info_dateOPget_month_data;
extern struct dbg_info* dbg_info_dateOPget_year;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPget_year_TRACE
int dateOPget_year_TRACE;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOPget_year_own_init = 0;

/**** BEGIN PROCEDURE get_year ****/

errcode dateOPget_year(d, ret_1)
CLUREF d;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d;
        } locals;
    locals.d.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPget_year;
    locals.d = d;
        if (dateOPget_year_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPget_year_own_init = 1;
    }
    enter_proc(49);

  LINE(50);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.d.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_year ****/

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;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPget_year_actual;
static Vlist1 vals_dateOPget_year = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_dateOPget_year = {0, 0};
static Vlist3 locals_dateOPget_year = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d", &struct_day_hour_minute_month_second_year_ops}}
};
static Vlist0 popowns_dateOPget_year = {0, 0};
Slist0 tformals_dateOPget_year = {0, 0};
Slist0 opformals_dateOPget_year = {0, 0};
dbg_info_dateOPget_year_actual dbg_info_dateOPget_year_data = {0, 12, 
    "dateOPget_year", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPget_year, 1, 
    &vals_dateOPget_year, &sigs_dateOPget_year, &locals_dateOPget_year, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPget_year = (struct dbg_info*)&dbg_info_dateOPget_year_data;
extern struct dbg_info* dbg_info_dateOPget_hour;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPget_hour_TRACE
int dateOPget_hour_TRACE;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOPget_hour_own_init = 0;

/**** BEGIN PROCEDURE get_hour ****/

errcode dateOPget_hour(d, ret_1)
CLUREF d;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d;
        } locals;
    locals.d.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPget_hour;
    locals.d = d;
        if (dateOPget_hour_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPget_hour_own_init = 1;
    }
    enter_proc(53);

  LINE(54);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.d.vec->data[1];
    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_hour ****/

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;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPget_hour_actual;
static Vlist1 vals_dateOPget_hour = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_dateOPget_hour = {0, 0};
static Vlist3 locals_dateOPget_hour = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d", &struct_day_hour_minute_month_second_year_ops}}
};
static Vlist0 popowns_dateOPget_hour = {0, 0};
Slist0 tformals_dateOPget_hour = {0, 0};
Slist0 opformals_dateOPget_hour = {0, 0};
dbg_info_dateOPget_hour_actual dbg_info_dateOPget_hour_data = {0, 12, 
    "dateOPget_hour", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPget_hour, 1, 
    &vals_dateOPget_hour, &sigs_dateOPget_hour, &locals_dateOPget_hour, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPget_hour = (struct dbg_info*)&dbg_info_dateOPget_hour_data;
extern struct dbg_info* dbg_info_dateOPget_minute;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPget_minute_TRACE
int dateOPget_minute_TRACE;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOPget_minute_own_init = 0;

/**** BEGIN PROCEDURE get_minute ****/

errcode dateOPget_minute(d, ret_1)
CLUREF d;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d;
        } locals;
    locals.d.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPget_minute;
    locals.d = d;
        if (dateOPget_minute_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPget_minute_own_init = 1;
    }
    enter_proc(57);

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

/**** END PROCEDURE get_minute ****/

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;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPget_minute_actual;
static Vlist1 vals_dateOPget_minute = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_dateOPget_minute = {0, 0};
static Vlist3 locals_dateOPget_minute = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d", &struct_day_hour_minute_month_second_year_ops}}
};
static Vlist0 popowns_dateOPget_minute = {0, 0};
Slist0 tformals_dateOPget_minute = {0, 0};
Slist0 opformals_dateOPget_minute = {0, 0};
dbg_info_dateOPget_minute_actual dbg_info_dateOPget_minute_data = {0, 12, 
    "dateOPget_minute", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPget_minute, 1, 
    &vals_dateOPget_minute, &sigs_dateOPget_minute, &locals_dateOPget_minute, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPget_minute = (struct dbg_info*)&dbg_info_dateOPget_minute_data;
extern struct dbg_info* dbg_info_dateOPget_second;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPget_second_TRACE
int dateOPget_second_TRACE;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOPget_second_own_init = 0;

/**** BEGIN PROCEDURE get_second ****/

errcode dateOPget_second(d, ret_1)
CLUREF d;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d;
        } locals;
    locals.d.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPget_second;
    locals.d = d;
        if (dateOPget_second_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPget_second_own_init = 1;
    }
    enter_proc(61);

  LINE(62);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.d.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_second ****/

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;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPget_second_actual;
static Vlist1 vals_dateOPget_second = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_dateOPget_second = {0, 0};
static Vlist3 locals_dateOPget_second = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d", &struct_day_hour_minute_month_second_year_ops}}
};
static Vlist0 popowns_dateOPget_second = {0, 0};
Slist0 tformals_dateOPget_second = {0, 0};
Slist0 opformals_dateOPget_second = {0, 0};
dbg_info_dateOPget_second_actual dbg_info_dateOPget_second_data = {0, 12, 
    "dateOPget_second", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPget_second, 1, 
    &vals_dateOPget_second, &sigs_dateOPget_second, &locals_dateOPget_second, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPget_second = (struct dbg_info*)&dbg_info_dateOPget_second_data;
extern struct dbg_info* dbg_info_dateOPget_all;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPget_all_TRACE
int dateOPget_all_TRACE;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOPget_all_own_init = 0;

/**** BEGIN PROCEDURE get_all ****/

errcode dateOPget_all(d, ret_1, ret_2, ret_3, ret_4, ret_5, ret_6)
CLUREF d;
CLUREF *ret_1;
CLUREF *ret_2;
CLUREF *ret_3;
CLUREF *ret_4;
CLUREF *ret_5;
CLUREF *ret_6;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d;
        } locals;
    locals.d.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPget_all;
    locals.d = d;
        if (dateOPget_all_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPget_all_own_init = 1;
    }
    enter_proc(65);

  LINE(66);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.d.vec->data[0];
    ret_1->num = T_1_1.num;
    }
    {
    CLUREF T_1_2;
    T_1_2.num = locals.d.vec->data[3];
    ret_2->num = T_1_2.num;
    }
    {
    CLUREF T_1_3;
    T_1_3.num = locals.d.vec->data[5];
    ret_3->num = T_1_3.num;
    }
    {
    CLUREF T_1_4;
    T_1_4.num = locals.d.vec->data[1];
    ret_4->num = T_1_4.num;
    }
    {
    CLUREF T_1_5;
    T_1_5.num = locals.d.vec->data[2];
    ret_5->num = T_1_5.num;
    }
    {
    CLUREF T_1_6;
    T_1_6.num = locals.d.vec->data[4];
    ret_6->num = T_1_6.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_all ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist6 *vals;
    siglist0 *sigs;
    Vlist3 *locals;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPget_all_actual;
static Vlist6 vals_dateOPget_all = {0, 6, { {0, 2, "", &int_ops},  {0, 2, "", &int_ops},  {0, 2, "", &int_ops},  {0, 2, "", &int_ops},  {0, 2, "", &int_ops},  {0, 2, "", &int_ops}}
};
static siglist0 sigs_dateOPget_all = {0, 0};
static Vlist3 locals_dateOPget_all = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d", &struct_day_hour_minute_month_second_year_ops}}
};
static Vlist0 popowns_dateOPget_all = {0, 0};
Slist0 tformals_dateOPget_all = {0, 0};
Slist0 opformals_dateOPget_all = {0, 0};
dbg_info_dateOPget_all_actual dbg_info_dateOPget_all_data = {0, 12, 
    "dateOPget_all", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPget_all, 1, 
    &vals_dateOPget_all, &sigs_dateOPget_all, &locals_dateOPget_all, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPget_all = (struct dbg_info*)&dbg_info_dateOPget_all_data;
extern struct dbg_info* dbg_info_dateOPunparse;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPunparse_TRACE
int dateOPunparse_TRACE;
extern OWN_req string_ownreqs;
static int dateOPunparse_own_init = 0;

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

errcode dateOPunparse(d, ret_1)
CLUREF d;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d;
        } locals;
    locals.d.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPunparse;
    locals.d = d;
        if (dateOPunparse_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPunparse_own_init = 1;
    }
    enter_proc(69);

  LINE(70);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    locals.err = dateOPunparse_date(locals.d, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = stringOPconcat(T_1_1, STR__040, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = dateOPunparse_time(locals.d, &T_1_3);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = stringOPconcat(T_1_2, T_1_3, &T_1_4);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_4.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

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

extern struct OPS *date_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;
    Vlist3 *locals;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPunparse_actual;
static Vlist1 vals_dateOPunparse = {0, 1, { {0, 2, "", &string_ops}}
};
static siglist0 sigs_dateOPunparse = {0, 0};
static Vlist3 locals_dateOPunparse = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d", &date_ops}}
};
static Vlist0 popowns_dateOPunparse = {0, 0};
Slist0 tformals_dateOPunparse = {0, 0};
Slist0 opformals_dateOPunparse = {0, 0};
dbg_info_dateOPunparse_actual dbg_info_dateOPunparse_data = {0, 12, 
    "dateOPunparse", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPunparse, 1, 
    &vals_dateOPunparse, &sigs_dateOPunparse, &locals_dateOPunparse, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPunparse = (struct dbg_info*)&dbg_info_dateOPunparse_data;
extern struct dbg_info* dbg_info_dateOPunparse_date;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPunparse_date_TRACE
int dateOPunparse_date_TRACE;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
struct OPS *sequence_of_string_table;
struct OPS *sequence_of_string_ops;
struct OPS *sequence_of_string_ops;
OWNPTR sequence_of_string_owns;
static int dateOPunparse_date_own_init = 0;

/**** BEGIN PROCEDURE unparse_date ****/

errcode dateOPunparse_date(d, ret_1)
CLUREF d;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d;
        } locals;
    locals.d.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPunparse_date;
    locals.d = d;
        if (dateOPunparse_date_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPunparse_date_own_init = 1;
    }
    enter_proc(73);

  LINE(78);
    {
    {
    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;
    CLUREF T_1_11;
    T_1_1.num = locals.d.vec->data[0];
    locals.err = intOPunparse(T_1_1, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = stringOPconcat(T_1_2, STR__040, &T_1_3);
    if (locals.err != ERR_ok) goto ex_0;
    sequenceOPnew2(CLU_12, &T_1_4);
    T_1_4.vec->data[0] = STR_January.num;
    T_1_4.vec->data[1] = STR_February.num;
    T_1_4.vec->data[2] = STR_March.num;
    T_1_4.vec->data[3] = STR_April.num;
    T_1_4.vec->data[4] = STR_May.num;
    T_1_4.vec->data[5] = STR_June.num;
    T_1_4.vec->data[6] = STR_July.num;
    T_1_4.vec->data[7] = STR_August.num;
    T_1_4.vec->data[8] = STR_September.num;
    T_1_4.vec->data[9] = STR_October.num;
    T_1_4.vec->data[10] = STR_November.num;
    T_1_4.vec->data[11] = STR_December.num;
    T_1_5.num = locals.d.vec->data[3];
    locals.err = sequenceOPfetch(T_1_4, T_1_5, &T_1_6);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = stringOPconcat(T_1_3, T_1_6, &T_1_7);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = stringOPconcat(T_1_7, STR__040, &T_1_8);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_9.num = locals.d.vec->data[5];
    locals.err = intOPunparse(T_1_9, &T_1_10);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = stringOPconcat(T_1_8, T_1_10, &T_1_11);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_11.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE unparse_date ****/

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;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPunparse_date_actual;
static Vlist1 vals_dateOPunparse_date = {0, 1, { {0, 2, "", &string_ops}}
};
static siglist0 sigs_dateOPunparse_date = {0, 0};
static Vlist3 locals_dateOPunparse_date = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d", &struct_day_hour_minute_month_second_year_ops}}
};
static Vlist0 popowns_dateOPunparse_date = {0, 0};
Slist0 tformals_dateOPunparse_date = {0, 0};
Slist0 opformals_dateOPunparse_date = {0, 0};
dbg_info_dateOPunparse_date_actual dbg_info_dateOPunparse_date_data = {0, 12, 
    "dateOPunparse_date", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPunparse_date, 1, 
    &vals_dateOPunparse_date, &sigs_dateOPunparse_date, &locals_dateOPunparse_date, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPunparse_date = (struct dbg_info*)&dbg_info_dateOPunparse_date_data;
extern struct dbg_info* dbg_info_dateOPunparse_time;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPunparse_time_TRACE
int dateOPunparse_time_TRACE;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOPunparse_time_own_init = 0;

/**** BEGIN PROCEDURE unparse_time ****/

errcode dateOPunparse_time(d, ret_1)
CLUREF d;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF hour;
        CLUREF minute;
        CLUREF second;
        CLUREF d;
        } locals;
    locals.hour.num = UNINIT;
    locals.minute.num = UNINIT;
    locals.second.num = UNINIT;
    locals.d.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPunparse_time;
    locals.d = d;
        if (dateOPunparse_time_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPunparse_time_own_init = 1;
    }
    enter_proc(83);

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

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

  LINE(86);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        T_1_1.num = locals.d.vec->data[4];
        locals.err = intOPunparse(T_1_1, &T_1_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.second.num = T_1_2.num;
        }
        }

  LINE(87);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.d.vec->data[1];
    T_1_2.num = (T_1_1.num < 10)? true : false;
    if (T_1_2.num == true) {

  LINE(88);
        {
        CLUREF T_2_1;
        locals.err = stringOPconcat(STR_0, locals.hour, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.hour.num = T_2_1.num;
        }
        }
        }/* end if */

  LINE(89);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.d.vec->data[2];
    T_1_2.num = (T_1_1.num < 10)? true : false;
    if (T_1_2.num == true) {

  LINE(90);
        {
        CLUREF T_2_1;
        locals.err = stringOPconcat(STR_0, locals.minute, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.minute.num = T_2_1.num;
        }
        }
        }/* end if */

  LINE(91);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.d.vec->data[4];
    T_1_2.num = (T_1_1.num < 10)? true : false;
    if (T_1_2.num == true) {

  LINE(92);
        {
        CLUREF T_2_1;
        locals.err = stringOPconcat(STR_0, locals.second, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.second.num = T_2_1.num;
        }
        }
        }/* end if */

  LINE(93);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    locals.err = stringOPconcat(locals.hour, STR__072, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = stringOPconcat(T_1_1, locals.minute, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = stringOPconcat(T_1_2, STR__072, &T_1_3);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = stringOPconcat(T_1_3, locals.second, &T_1_4);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_4.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE unparse_time ****/

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;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPunparse_time_actual;
static Vlist1 vals_dateOPunparse_time = {0, 1, { {0, 2, "", &string_ops}}
};
static siglist0 sigs_dateOPunparse_time = {0, 0};
static Vlist6 locals_dateOPunparse_time = {0, 6,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "hour", &string_ops},  {0, 2, "minute", &string_ops},  {0, 2, "second", &string_ops},  {0, 2, "d", &struct_day_hour_minute_month_second_year_ops}}
};
static Vlist0 popowns_dateOPunparse_time = {0, 0};
Slist0 tformals_dateOPunparse_time = {0, 0};
Slist0 opformals_dateOPunparse_time = {0, 0};
dbg_info_dateOPunparse_time_actual dbg_info_dateOPunparse_time_data = {0, 12, 
    "dateOPunparse_time", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPunparse_time, 1, 
    &vals_dateOPunparse_time, &sigs_dateOPunparse_time, &locals_dateOPunparse_time, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPunparse_time = (struct dbg_info*)&dbg_info_dateOPunparse_time_data;
extern struct dbg_info* dbg_info_dateOPequal;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPequal_TRACE
int dateOPequal_TRACE;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOPequal_own_init = 0;

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

errcode dateOPequal(date1, date2, ret_1)
CLUREF date1;
CLUREF date2;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF date1;
        CLUREF date2;
        } locals;
    locals.date1.num = UNINIT;
    locals.date2.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPequal;
    locals.date1 = date1;
    locals.date2 = date2;
        if (dateOPequal_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPequal_own_init = 1;
    }
    enter_proc(96);

  LINE(97);
    {

  LINE(98);
        {
        {
        CLUREF T_2_1;
        generic_CLU_proc.type_owns = 0;
        generic_CLU_proc.op_owns = struct_day_hour_minute_month_second_year_ops->entry[0].fcn->op_owns;
        generic_CLU_proc.proc = structOPequal;
        CUR_PROC_VAR.proc = &generic_CLU_proc;
        locals.err = structOPequal(locals.date1, locals.date2, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        ret_1->num = T_2_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 ****/

extern struct OPS *bool_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPequal_actual;
static Vlist1 vals_dateOPequal = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_dateOPequal = {0, 0};
static Vlist4 locals_dateOPequal = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "date1", &struct_day_hour_minute_month_second_year_ops},  {0, 2, "date2", &struct_day_hour_minute_month_second_year_ops}}
};
static Vlist0 popowns_dateOPequal = {0, 0};
Slist0 tformals_dateOPequal = {0, 0};
Slist0 opformals_dateOPequal = {0, 0};
dbg_info_dateOPequal_actual dbg_info_dateOPequal_data = {0, 12, 
    "dateOPequal", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPequal, 2, 
    &vals_dateOPequal, &sigs_dateOPequal, &locals_dateOPequal, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPequal = (struct dbg_info*)&dbg_info_dateOPequal_data;
extern struct dbg_info* dbg_info_dateOPsimilar;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPsimilar_TRACE
int dateOPsimilar_TRACE;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOPsimilar_own_init = 0;

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

errcode dateOPsimilar(date1, date2, ret_1)
CLUREF date1;
CLUREF date2;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF date1;
        CLUREF date2;
        } locals;
    locals.date1.num = UNINIT;
    locals.date2.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPsimilar;
    locals.date1 = date1;
    locals.date2 = date2;
        if (dateOPsimilar_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPsimilar_own_init = 1;
    }
    enter_proc(102);

  LINE(103);
    {
    {
    CLUREF T_1_1;
    generic_CLU_proc.type_owns = 0;
    generic_CLU_proc.op_owns = struct_day_hour_minute_month_second_year_ops->entry[0].fcn->op_owns;
    generic_CLU_proc.proc = structOPequal;
    CUR_PROC_VAR.proc = &generic_CLU_proc;
    locals.err = structOPequal(locals.date1, locals.date2, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_1.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

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

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPsimilar_actual;
static Vlist1 vals_dateOPsimilar = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_dateOPsimilar = {0, 0};
static Vlist4 locals_dateOPsimilar = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "date1", &struct_day_hour_minute_month_second_year_ops},  {0, 2, "date2", &struct_day_hour_minute_month_second_year_ops}}
};
static Vlist0 popowns_dateOPsimilar = {0, 0};
Slist0 tformals_dateOPsimilar = {0, 0};
Slist0 opformals_dateOPsimilar = {0, 0};
dbg_info_dateOPsimilar_actual dbg_info_dateOPsimilar_data = {0, 12, 
    "dateOPsimilar", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPsimilar, 2, 
    &vals_dateOPsimilar, &sigs_dateOPsimilar, &locals_dateOPsimilar, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPsimilar = (struct dbg_info*)&dbg_info_dateOPsimilar_data;
extern struct dbg_info* dbg_info_dateOPcopy;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPcopy_TRACE
int dateOPcopy_TRACE;

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

errcode dateOPcopy(d, ret_1)
CLUREF d;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d;
        } locals;
    locals.d.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPcopy;
    locals.d = d;
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
    enter_proc(106);

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

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

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist3 *locals;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPcopy_actual;
static Vlist1 vals_dateOPcopy = {0, 1, { {0, 2, "", &date_ops}}
};
static siglist0 sigs_dateOPcopy = {0, 0};
static Vlist3 locals_dateOPcopy = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d", &date_ops}}
};
static Vlist0 popowns_dateOPcopy = {0, 0};
Slist0 tformals_dateOPcopy = {0, 0};
Slist0 opformals_dateOPcopy = {0, 0};
dbg_info_dateOPcopy_actual dbg_info_dateOPcopy_data = {0, 12, 
    "dateOPcopy", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPcopy, 1, 
    &vals_dateOPcopy, &sigs_dateOPcopy, &locals_dateOPcopy, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPcopy = (struct dbg_info*)&dbg_info_dateOPcopy_data;
extern struct dbg_info* dbg_info_dateOPlt;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPlt_TRACE
int dateOPlt_TRACE;
extern OWN_req bool_ownreqs;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOPlt_own_init = 0;

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

errcode dateOPlt(d1, d2, ret_1)
CLUREF d1;
CLUREF d2;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d1;
        CLUREF d2;
        } locals;
    locals.d1.num = UNINIT;
    locals.d2.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPlt;
    locals.d1 = d1;
    locals.d2 = d2;
        if (dateOPlt_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPlt_own_init = 1;
    }
    enter_proc(110);

  LINE(111);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.d1.vec->data[5];
    T_1_2.num = locals.d2.vec->data[5];
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    T_1_4.num = T_1_3.num ^ 1;
    if (T_1_4.num == true) {

  LINE(112);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.d1.vec->data[5];
        T_2_2.num = locals.d2.vec->data[5];
        T_2_3.num = (T_2_1.num < T_2_2.num)? true : false;
        ret_1->num = T_2_3.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(113);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.d1.vec->data[3];
    T_1_2.num = locals.d2.vec->data[3];
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    T_1_4.num = T_1_3.num ^ 1;
    if (T_1_4.num == true) {

  LINE(114);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.d1.vec->data[3];
        T_2_2.num = locals.d2.vec->data[3];
        T_2_3.num = (T_2_1.num < T_2_2.num)? true : false;
        ret_1->num = T_2_3.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(115);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.d1.vec->data[0];
    T_1_2.num = locals.d2.vec->data[0];
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    T_1_4.num = T_1_3.num ^ 1;
    if (T_1_4.num == true) {

  LINE(116);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.d1.vec->data[0];
        T_2_2.num = locals.d2.vec->data[0];
        T_2_3.num = (T_2_1.num < T_2_2.num)? true : false;
        ret_1->num = T_2_3.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(117);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.d1.vec->data[1];
    T_1_2.num = locals.d2.vec->data[1];
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    T_1_4.num = T_1_3.num ^ 1;
    if (T_1_4.num == true) {

  LINE(118);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.d1.vec->data[1];
        T_2_2.num = locals.d2.vec->data[1];
        T_2_3.num = (T_2_1.num < T_2_2.num)? true : false;
        ret_1->num = T_2_3.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(119);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.d1.vec->data[2];
    T_1_2.num = locals.d2.vec->data[2];
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    T_1_4.num = T_1_3.num ^ 1;
    if (T_1_4.num == true) {

  LINE(120);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.d1.vec->data[2];
        T_2_2.num = locals.d2.vec->data[2];
        T_2_3.num = (T_2_1.num < T_2_2.num)? true : false;
        ret_1->num = T_2_3.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

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

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

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPlt_actual;
static Vlist1 vals_dateOPlt = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_dateOPlt = {0, 0};
static Vlist4 locals_dateOPlt = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d1", &struct_day_hour_minute_month_second_year_ops},  {0, 2, "d2", &struct_day_hour_minute_month_second_year_ops}}
};
static Vlist0 popowns_dateOPlt = {0, 0};
Slist0 tformals_dateOPlt = {0, 0};
Slist0 opformals_dateOPlt = {0, 0};
dbg_info_dateOPlt_actual dbg_info_dateOPlt_data = {0, 12, 
    "dateOPlt", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPlt, 2, 
    &vals_dateOPlt, &sigs_dateOPlt, &locals_dateOPlt, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPlt = (struct dbg_info*)&dbg_info_dateOPlt_data;
extern struct dbg_info* dbg_info_dateOPle;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPle_TRACE
int dateOPle_TRACE;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOPle_own_init = 0;

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

errcode dateOPle(d1, d2, ret_1)
CLUREF d1;
CLUREF d2;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d1;
        CLUREF d2;
        } locals;
    locals.d1.num = UNINIT;
    locals.d2.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPle;
    locals.d1 = d1;
    locals.d2 = d2;
        if (dateOPle_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPle_own_init = 1;
    }
    enter_proc(124);

  LINE(125);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.d1.vec->data[5];
    T_1_2.num = locals.d2.vec->data[5];
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    T_1_4.num = T_1_3.num ^ 1;
    if (T_1_4.num == true) {

  LINE(126);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.d1.vec->data[5];
        T_2_2.num = locals.d2.vec->data[5];
        T_2_3.num = (T_2_1.num < T_2_2.num)? true : false;
        ret_1->num = T_2_3.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(127);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.d1.vec->data[3];
    T_1_2.num = locals.d2.vec->data[3];
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    T_1_4.num = T_1_3.num ^ 1;
    if (T_1_4.num == true) {

  LINE(128);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.d1.vec->data[3];
        T_2_2.num = locals.d2.vec->data[3];
        T_2_3.num = (T_2_1.num < T_2_2.num)? true : false;
        ret_1->num = T_2_3.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(129);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.d1.vec->data[0];
    T_1_2.num = locals.d2.vec->data[0];
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    T_1_4.num = T_1_3.num ^ 1;
    if (T_1_4.num == true) {

  LINE(130);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.d1.vec->data[0];
        T_2_2.num = locals.d2.vec->data[0];
        T_2_3.num = (T_2_1.num < T_2_2.num)? true : false;
        ret_1->num = T_2_3.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(131);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.d1.vec->data[1];
    T_1_2.num = locals.d2.vec->data[1];
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    T_1_4.num = T_1_3.num ^ 1;
    if (T_1_4.num == true) {

  LINE(132);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.d1.vec->data[1];
        T_2_2.num = locals.d2.vec->data[1];
        T_2_3.num = (T_2_1.num < T_2_2.num)? true : false;
        ret_1->num = T_2_3.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(133);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.d1.vec->data[2];
    T_1_2.num = locals.d2.vec->data[2];
    T_1_3.num = (T_1_1.num == T_1_2.num)? true : false;
    T_1_4.num = T_1_3.num ^ 1;
    if (T_1_4.num == true) {

  LINE(134);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.d1.vec->data[2];
        T_2_2.num = locals.d2.vec->data[2];
        T_2_3.num = (T_2_1.num < T_2_2.num)? true : false;
        ret_1->num = T_2_3.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

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

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

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPle_actual;
static Vlist1 vals_dateOPle = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_dateOPle = {0, 0};
static Vlist4 locals_dateOPle = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d1", &struct_day_hour_minute_month_second_year_ops},  {0, 2, "d2", &struct_day_hour_minute_month_second_year_ops}}
};
static Vlist0 popowns_dateOPle = {0, 0};
Slist0 tformals_dateOPle = {0, 0};
Slist0 opformals_dateOPle = {0, 0};
dbg_info_dateOPle_actual dbg_info_dateOPle_data = {0, 12, 
    "dateOPle", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPle, 2, 
    &vals_dateOPle, &sigs_dateOPle, &locals_dateOPle, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPle = (struct dbg_info*)&dbg_info_dateOPle_data;
extern struct dbg_info* dbg_info_dateOPgt;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPgt_TRACE
int dateOPgt_TRACE;
extern OWN_req date_ownreqs;
static int dateOPgt_own_init = 0;

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

errcode dateOPgt(d1, d2, ret_1)
CLUREF d1;
CLUREF d2;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d1;
        CLUREF d2;
        } locals;
    locals.d1.num = UNINIT;
    locals.d2.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPgt;
    locals.d1 = d1;
    locals.d2 = d2;
        if (dateOPgt_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPgt_own_init = 1;
    }
    enter_proc(138);

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

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

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPgt_actual;
static Vlist1 vals_dateOPgt = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_dateOPgt = {0, 0};
static Vlist4 locals_dateOPgt = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d1", &date_ops},  {0, 2, "d2", &date_ops}}
};
static Vlist0 popowns_dateOPgt = {0, 0};
Slist0 tformals_dateOPgt = {0, 0};
Slist0 opformals_dateOPgt = {0, 0};
dbg_info_dateOPgt_actual dbg_info_dateOPgt_data = {0, 12, 
    "dateOPgt", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPgt, 2, 
    &vals_dateOPgt, &sigs_dateOPgt, &locals_dateOPgt, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPgt = (struct dbg_info*)&dbg_info_dateOPgt_data;
extern struct dbg_info* dbg_info_dateOPge;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPge_TRACE
int dateOPge_TRACE;
static int dateOPge_own_init = 0;

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

errcode dateOPge(d1, d2, ret_1)
CLUREF d1;
CLUREF d2;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d1;
        CLUREF d2;
        } locals;
    locals.d1.num = UNINIT;
    locals.d2.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPge;
    locals.d1 = d1;
    locals.d2 = d2;
        if (dateOPge_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPge_own_init = 1;
    }
    enter_proc(142);

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

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

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPge_actual;
static Vlist1 vals_dateOPge = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_dateOPge = {0, 0};
static Vlist4 locals_dateOPge = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d1", &date_ops},  {0, 2, "d2", &date_ops}}
};
static Vlist0 popowns_dateOPge = {0, 0};
Slist0 tformals_dateOPge = {0, 0};
Slist0 opformals_dateOPge = {0, 0};
dbg_info_dateOPge_actual dbg_info_dateOPge_data = {0, 12, 
    "dateOPge", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPge, 2, 
    &vals_dateOPge, &sigs_dateOPge, &locals_dateOPge, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPge = (struct dbg_info*)&dbg_info_dateOPge_data;
extern struct dbg_info* dbg_info_dateOPprint;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPprint_TRACE
int dateOPprint_TRACE;
extern OWN_req pstream_ownreqs;
extern struct OPS *pstream_ops;
static int dateOPprint_own_init = 0;

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

errcode dateOPprint(d, ps)
CLUREF d;
CLUREF ps;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d;
        CLUREF ps;
        } locals;
    locals.d.num = UNINIT;
    locals.ps.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPprint;
    locals.d = d;
    locals.ps = ps;
        if (dateOPprint_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPprint_own_init = 1;
    }
    enter_proc(146);

  LINE(147);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    locals.err = dateOPunparse(locals.d, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = pstreamOPtext(locals.ps, 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;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPprint_actual;
static Vlist0 vals_dateOPprint = {0, 0};
static siglist0 sigs_dateOPprint = {0, 0};
static Vlist4 locals_dateOPprint = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d", &date_ops},  {0, 2, "ps", &pstream_ops}}
};
static Vlist0 popowns_dateOPprint = {0, 0};
Slist0 tformals_dateOPprint = {0, 0};
Slist0 opformals_dateOPprint = {0, 0};
dbg_info_dateOPprint_actual dbg_info_dateOPprint_data = {0, 12, 
    "dateOPprint", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPprint, 2, 
    &vals_dateOPprint, &sigs_dateOPprint, &locals_dateOPprint, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPprint = (struct dbg_info*)&dbg_info_dateOPprint_data;
extern struct dbg_info* dbg_info_dateOPencode;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPencode_TRACE
int dateOPencode_TRACE;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOPencode_own_init = 0;

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

errcode dateOPencode(d, ist)
CLUREF d;
CLUREF ist;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d;
        CLUREF ist;
        } locals;
    locals.d.num = UNINIT;
    locals.ist.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPencode;
    locals.d = d;
    locals.ist = ist;
        if (dateOPencode_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPencode_own_init = 1;
    }
    enter_proc(150);

  LINE(151);
    {

  LINE(152);
        {
        CLUREF T_3_1;
        T_3_1.num = locals.d.vec->data[0];
        locals.err = intOPencode(T_3_1, locals.ist);
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(153);
        {
        CLUREF T_3_1;
        T_3_1.num = locals.d.vec->data[3];
        locals.err = intOPencode(T_3_1, locals.ist);
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(154);
        {
        CLUREF T_3_1;
        T_3_1.num = locals.d.vec->data[5];
        locals.err = intOPencode(T_3_1, locals.ist);
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(155);
        {
        CLUREF T_3_1;
        T_3_1.num = locals.d.vec->data[1];
        locals.err = intOPencode(T_3_1, locals.ist);
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(156);
        {
        CLUREF T_3_1;
        T_3_1.num = locals.d.vec->data[2];
        locals.err = intOPencode(T_3_1, locals.ist);
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(157);
        {
        CLUREF T_3_1;
        T_3_1.num = locals.d.vec->data[4];
        locals.err = intOPencode(T_3_1, locals.ist);
        if (locals.err != ERR_ok) goto ex_1;
        }
        }
    goto end_1;
    ex_1:
        if (locals.err == ERR_not_possible) {signal(ERR_not_possible);}
        else {
            goto ex_0;}
    end_1:;
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

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

extern struct OPS *istream_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist0 *vals;
    siglist1 *sigs;
    Vlist4 *locals;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPencode_actual;
static Vlist0 vals_dateOPencode = {0, 0};
static sig_desc1 sig_dateOPencode_1 = {0, 4, "not_possible", {0, 1
, { {0, 2, "", &string_ops}}}};
static siglist1 sigs_dateOPencode = {0, 1, (sig_desc*)&sig_dateOPencode_1};
static Vlist4 locals_dateOPencode = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d", &struct_day_hour_minute_month_second_year_ops},  {0, 2, "ist", &istream_ops}}
};
static Vlist0 popowns_dateOPencode = {0, 0};
Slist0 tformals_dateOPencode = {0, 0};
Slist0 opformals_dateOPencode = {0, 0};
dbg_info_dateOPencode_actual dbg_info_dateOPencode_data = {0, 12, 
    "dateOPencode", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPencode, 2, 
    &vals_dateOPencode, &sigs_dateOPencode, &locals_dateOPencode, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPencode = (struct dbg_info*)&dbg_info_dateOPencode_data;
extern struct dbg_info* dbg_info_dateOPdecode;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPdecode_TRACE
int dateOPdecode_TRACE;
static int dateOPdecode_own_init = 0;

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

errcode dateOPdecode(ist, ret_1)
CLUREF ist;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF ist;
        } locals;
    locals.ist.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOPdecode;
    locals.ist = ist;
        if (dateOPdecode_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPdecode_own_init = 1;
    }
    enter_proc(161);

  LINE(163);
    {
    {
    CLUREF T_3_1;
    CLUREF T_3_2;
    CLUREF T_3_3;
    CLUREF T_3_4;
    CLUREF T_3_5;
    CLUREF T_3_6;
    CLUREF T_3_7;
    locals.err = intOPdecode(locals.ist, &T_3_1);
    if (locals.err != ERR_ok) goto ex_2;
    locals.err = intOPdecode(locals.ist, &T_3_2);
    if (locals.err != ERR_ok) goto ex_2;
    locals.err = intOPdecode(locals.ist, &T_3_3);
    if (locals.err != ERR_ok) goto ex_2;
    locals.err = intOPdecode(locals.ist, &T_3_4);
    if (locals.err != ERR_ok) goto ex_2;
    locals.err = intOPdecode(locals.ist, &T_3_5);
    if (locals.err != ERR_ok) goto ex_2;
    locals.err = intOPdecode(locals.ist, &T_3_6);
    if (locals.err != ERR_ok) goto ex_2;
    locals.err = dateOPcreate(T_3_1, T_3_2, T_3_3, T_3_4, T_3_5, T_3_6, &T_3_7);
    if (locals.err != ERR_ok) goto ex_2;
    ret_1->num = T_3_7.num;
    }
    {signal (ERR_ok);}}
    goto end_2;
    ex_2:
        if (locals.err == ERR_end_of_file) {signal(ERR_end_of_file);}
        else if (locals.err == ERR_not_possible) {signal(ERR_not_possible);}
        else {
            goto ex_1;}
    end_2:;
        goto end_1;
        ex_1:
            if ((locals.err == ERR_bad_format)) {

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

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

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist2 *sigs;
    Vlist3 *locals;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPdecode_actual;
static Vlist1 vals_dateOPdecode = {0, 1, { {0, 2, "", &date_ops}}
};
static sig_desc0 sig_dateOPdecode_1 = {0, 3, "end_of_file", {0, 0
}};
static sig_desc1 sig_dateOPdecode_2 = {0, 4, "not_possible", {0, 1
, { {0, 2, "", &string_ops}}}};
static siglist2 sigs_dateOPdecode = {0, 2, (sig_desc*)&sig_dateOPdecode_1, (sig_desc*)&sig_dateOPdecode_2};
static Vlist3 locals_dateOPdecode = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ist", &istream_ops}}
};
static Vlist0 popowns_dateOPdecode = {0, 0};
Slist0 tformals_dateOPdecode = {0, 0};
Slist0 opformals_dateOPdecode = {0, 0};
dbg_info_dateOPdecode_actual dbg_info_dateOPdecode_data = {0, 12, 
    "dateOPdecode", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPdecode, 1, 
    &vals_dateOPdecode, &sigs_dateOPdecode, &locals_dateOPdecode, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPdecode = (struct dbg_info*)&dbg_info_dateOPdecode_data;
extern struct dbg_info* dbg_info_dateOP_gcd;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOP_gcd_TRACE
int dateOP_gcd_TRACE;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOP_gcd_own_init = 0;

/**** BEGIN PROCEDURE _gcd ****/

errcode dateOP_gcd(d, tab, ret_1)
CLUREF d;
CLUREF tab;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF d;
        CLUREF tab;
        } locals;
    locals.d.num = UNINIT;
    locals.tab.num = UNINIT;
    locals.DBG_INFO = dbg_info_dateOP_gcd;
    locals.d = d;
    locals.tab = tab;
        if (dateOP_gcd_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOP_gcd_own_init = 1;
    }
    enter_proc(169);

  LINE(170);
    {
    {
    CLUREF T_1_1;
    generic_CLU_proc.type_owns = 0;
    generic_CLU_proc.op_owns = struct_day_hour_minute_month_second_year_ops->entry[6].fcn->op_owns;
    generic_CLU_proc.proc = structOP_gcd;
    CUR_PROC_VAR.proc = &generic_CLU_proc;
    locals.err = structOP_gcd(locals.d, locals.tab, &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 _gcd ****/

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;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOP_gcd_actual;
static Vlist1 vals_dateOP_gcd = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_dateOP_gcd = {0, 0};
static Vlist4 locals_dateOP_gcd = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "d", &struct_day_hour_minute_month_second_year_ops},  {0, 2, "tab", &gcd_tab_ops}}
};
static Vlist0 popowns_dateOP_gcd = {0, 0};
Slist0 tformals_dateOP_gcd = {0, 0};
Slist0 opformals_dateOP_gcd = {0, 0};
dbg_info_dateOP_gcd_actual dbg_info_dateOP_gcd_data = {0, 12, 
    "dateOP_gcd", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOP_gcd, 2, 
    &vals_dateOP_gcd, &sigs_dateOP_gcd, &locals_dateOP_gcd, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOP_gcd = (struct dbg_info*)&dbg_info_dateOP_gcd_data;
extern struct dbg_info* dbg_info_dateOPdebug_print;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG dateOPdebug_print_TRACE
int dateOPdebug_print_TRACE;
struct OPS  *struct_day_hour_minute_month_second_year_ops;
static int dateOPdebug_print_own_init = 0;

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

errcode dateOPdebug_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_dateOPdebug_print;
    locals._rep = _rep;
    locals.ps = ps;
        if (dateOPdebug_print_own_init == 0) {
        if (date_own_init == 0) {
            locals.err = date_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        dateOPdebug_print_own_init = 1;
    }
    enter_proc(1);

  LINE(2);
    {
    locals.err = dateOPprint(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;
    Vlist24 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_dateOPdebug_print_actual;
static Vlist0 vals_dateOPdebug_print = {0, 0};
static siglist0 sigs_dateOPdebug_print = {0, 0};
static Vlist4 locals_dateOPdebug_print = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "_rep", &struct_day_hour_minute_month_second_year_ops},  {0, 2, "ps", &pstream_ops}}
};
static Vlist0 popowns_dateOPdebug_print = {0, 0};
Slist0 tformals_dateOPdebug_print = {0, 0};
Slist0 opformals_dateOPdebug_print = {0, 0};
dbg_info_dateOPdebug_print_actual dbg_info_dateOPdebug_print_data = {0, 12, 
    "dateOPdebug_print", "/common/pub/dcurtis-temp/pclu/sys/clu/date", 0, 0, (int)dateOPdebug_print, 2, 
    &vals_dateOPdebug_print, &sigs_dateOPdebug_print, &locals_dateOPdebug_print, &owns_date, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_dateOPdebug_print = (struct dbg_info*)&dbg_info_dateOPdebug_print_data;
typedef struct{
    int count;
    OWNPTR type_owns;
    OWNPTR op_owns;
    struct OP_ENTRY entry[23];
} date_OPS;

CLU_proc date_oe__gcd = {{0,0,0,0}, dateOP_gcd, 0};
CLU_proc date_oe_copy = {{0,0,0,0}, dateOPcopy, 0};
CLU_proc date_oe_create = {{0,0,0,0}, dateOPcreate, 0};
CLU_proc date_oe_decode = {{0,0,0,0}, dateOPdecode, 0};
CLU_proc date_oe_encode = {{0,0,0,0}, dateOPencode, 0};
CLU_proc date_oe_equal = {{0,0,0,0}, dateOPequal, 0};
CLU_proc date_oe_ge = {{0,0,0,0}, dateOPge, 0};
CLU_proc date_oe_get_all = {{0,0,0,0}, dateOPget_all, 0};
CLU_proc date_oe_get_day = {{0,0,0,0}, dateOPget_day, 0};
CLU_proc date_oe_get_hour = {{0,0,0,0}, dateOPget_hour, 0};
CLU_proc date_oe_get_minute = {{0,0,0,0}, dateOPget_minute, 0};
CLU_proc date_oe_get_month = {{0,0,0,0}, dateOPget_month, 0};
CLU_proc date_oe_get_second = {{0,0,0,0}, dateOPget_second, 0};
CLU_proc date_oe_get_year = {{0,0,0,0}, dateOPget_year, 0};
CLU_proc date_oe_gt = {{0,0,0,0}, dateOPgt, 0};
CLU_proc date_oe_le = {{0,0,0,0}, dateOPle, 0};
CLU_proc date_oe_lt = {{0,0,0,0}, dateOPlt, 0};
CLU_proc date_oe_print = {{0,0,0,0}, dateOPprint, 0};
CLU_proc date_oe_similar = {{0,0,0,0}, dateOPsimilar, 0};
CLU_proc date_oe_unparse = {{0,0,0,0}, dateOPunparse, 0};
CLU_proc date_oe_unparse_date = {{0,0,0,0}, dateOPunparse_date, 0};
CLU_proc date_oe_unparse_time = {{0,0,0,0}, dateOPunparse_time, 0};
CLU_proc date_oe_debug_print = {{0,0,0,0}, dateOPdebug_print, 0};

date_OPS date_ops_actual = {23, (OWNPTR)&date_own_init, (OWNPTR)&date_own_init, {
    {&date_oe__gcd, "_gcd"},
    {&date_oe_copy, "copy"},
    {&date_oe_create, "create"},
    {&date_oe_decode, "decode"},
    {&date_oe_encode, "encode"},
    {&date_oe_equal, "equal"},
    {&date_oe_ge, "ge"},
    {&date_oe_get_all, "get_all"},
    {&date_oe_get_day, "get_day"},
    {&date_oe_get_hour, "get_hour"},
    {&date_oe_get_minute, "get_minute"},
    {&date_oe_get_month, "get_month"},
    {&date_oe_get_second, "get_second"},
    {&date_oe_get_year, "get_year"},
    {&date_oe_gt, "gt"},
    {&date_oe_le, "le"},
    {&date_oe_lt, "lt"},
    {&date_oe_print, "print"},
    {&date_oe_similar, "similar"},
    {&date_oe_unparse, "unparse"},
    {&date_oe_unparse_date, "unparse_date"},
    {&date_oe_unparse_time, "unparse_time"},
    {&date_oe_debug_print, "debug_print"}}};

struct OPS *date_ops = (struct OPS *)&date_ops_actual;

/**** END CLUSTER date ****/
