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

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


/**** BEGIN CLUSTER time ****/

extern errcode time_IB_1();
extern errcode intOPlt();
extern errcode intOPadd();
extern errcode intOPdiv();
extern errcode intOPmod();
extern errcode structOPget_1();
extern errcode structOPget_2();
extern errcode structOPget_5();
extern errcode structOPget_6();
extern errcode structOPget_4();
extern errcode structOPget_3();
extern errcode timeOPget_all();
extern errcode intOPge();
extern errcode intOPsub();
extern errcode timeOPgt();
extern errcode timeOPdo_div();
extern errcode intOPmul();
extern errcode timeOPaverage();
extern errcode intOPle();
extern errcode intOPfrom_to();
extern errcode boolOPnot();
extern errcode intOPequal();
extern errcode timeOPlt();
extern errcode timeOPequal();
extern errcode timeOPle();
extern errcode arrayOPpredict();
extern errcode stringOPindexc();
extern errcode arrayOPaddh();
extern errcode intOPparse();
extern errcode stringOPsubstr();
extern errcode stringOPrest();
extern errcode intOPgt();
extern errcode arrayOPsize();
extern errcode arrayOPaddl();
extern errcode stringOPsize();
extern errcode stringOPappend();
extern errcode stringOPempty();
extern errcode arrayOPset_low();
extern errcode timeOPcreate();
extern errcode arrayOPfetch();
extern errcode timeOPformat();
extern errcode realOPadd();
extern errcode realOPdiv();
extern errcode realOPi2r();
extern errcode realOPmul();
extern errcode intOPunparse();
extern errcode stringOPconcat();
extern errcode pstreamOPtext();
extern errcode timeOPunparse();
extern errcode structOPequal();
extern errcode stringOPencode();
extern errcode timeOPparse();
extern errcode stringOPdecode();
extern errcode structOP_gcd();
extern errcode timeOPprint();
extern OWN_req gcd_tab_ownreqs;
extern struct OPS *gcd_tab_ops;
extern struct OPS *int_ops;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
extern struct REQS *array_of_t_reqs;
extern OWN_req array_ownreqs;
extern struct OPS *array_ops;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
CLUREF STR_;
CLUREF STR_bad_040format;
static int time_own_init = 0;
OWN_req time_ownreqs = {0,0};
errcode time_own_init_proc()
{
struct {
    errcode err;
    } locals;
    enter_own_init_proc();
        if (time_own_init == 0) {
        add_selector_info("days", 0, int_ops); 
        add_selector_info("hours", 1, int_ops); 
        add_selector_info("micros", 2, int_ops); 
        add_selector_info("millis", 3, int_ops); 
        add_selector_info("mins", 4, int_ops); 
        add_selector_info("secs", 5, int_ops); 
        find_selector_ops("struct", 6, &(struct_days_hours_micros_millis_mins_secs_ops));
        add_parm_info_type(0, int_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(array_of_int_ops));
        stringOPcons("", CLU_1, CLU_0, &STR_);
        stringOPcons("bad format", CLU_1, CLU_10, &STR_bad_040format);
        time_own_init = 1;
        {signal(ERR_ok);}
    ex_0: pclu_unhandled(locals.err); {signal(ERR_failure);}
        }
    }

extern struct dbg_info* dbg_info_timeOPcreate;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPcreate_TRACE
int timeOPcreate_TRACE;
static Vlist31 owns_time = {0, 31,{ {0, 2, "time_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
, {0, 2, "timeOPcreate_init", &int_ops}
}
};
extern OWN_req int_ownreqs;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPcreate_own_init = 0;

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

errcode timeOPcreate(days, hours, mins, secs, millis, micros, ret_1)
CLUREF days;
CLUREF hours;
CLUREF mins;
CLUREF secs;
CLUREF millis;
CLUREF micros;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF days;
        CLUREF hours;
        CLUREF mins;
        CLUREF secs;
        CLUREF millis;
        CLUREF micros;
        } locals;
    locals.days.num = UNINIT;
    locals.hours.num = UNINIT;
    locals.mins.num = UNINIT;
    locals.secs.num = UNINIT;
    locals.millis.num = UNINIT;
    locals.micros.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPcreate;
    locals.days = days;
    locals.hours = hours;
    locals.mins = mins;
    locals.secs = secs;
    locals.millis = millis;
    locals.micros = micros;
        if (timeOPcreate_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPcreate_own_init = 1;
    }
    enter_proc(12);

  LINE(14);
    {

  LINE(15);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        CLUREF T_3_4;
        CLUREF T_3_5;
        CLUREF T_3_6;
        CLUREF T_3_7;
        CLUREF T_3_8;
        CLUREF T_3_9;
        CLUREF T_3_10;
        CLUREF T_3_11;
        T_3_6.num = (locals.days.num < 0)? true : false;
        T_3_5.num = T_3_6.num;
        if (!T_3_6.num) {
            T_3_7.num = (locals.hours.num < 0)? true : false;
            T_3_5.num = T_3_7.num;
        }
        T_3_4.num = T_3_5.num;
        if (!T_3_5.num) {
            T_3_8.num = (locals.mins.num < 0)? true : false;
            T_3_4.num = T_3_8.num;
        }
        T_3_3.num = T_3_4.num;
        if (!T_3_4.num) {
            T_3_9.num = (locals.secs.num < 0)? true : false;
            T_3_3.num = T_3_9.num;
        }
        T_3_2.num = T_3_3.num;
        if (!T_3_3.num) {
            T_3_10.num = (locals.millis.num < 0)? true : false;
            T_3_2.num = T_3_10.num;
        }
        T_3_1.num = T_3_2.num;
        if (!T_3_2.num) {
            T_3_11.num = (locals.micros.num < 0)? true : false;
            T_3_1.num = T_3_11.num;
        }
        if (T_3_1.num == true) {

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

  LINE(18);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        T_3_1.num = 1000;
        locals.err = intOPdiv(locals.micros, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.err = intOPadd(locals.millis, T_3_2, &T_3_3);
        if (locals.err != ERR_ok) goto ex_1;
        locals.millis.num = T_3_3.num;
        }

  LINE(19);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        T_3_1.num = 1000;
        locals.err = intOPmod(locals.micros, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.micros.num = T_3_2.num;
        }

  LINE(20);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        T_3_1.num = 1000;
        locals.err = intOPdiv(locals.millis, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.err = intOPadd(locals.secs, T_3_2, &T_3_3);
        if (locals.err != ERR_ok) goto ex_1;
        locals.secs.num = T_3_3.num;
        }

  LINE(21);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        T_3_1.num = 1000;
        locals.err = intOPmod(locals.millis, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.millis.num = T_3_2.num;
        }

  LINE(22);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        T_3_1.num = 60;
        locals.err = intOPdiv(locals.secs, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.err = intOPadd(locals.mins, T_3_2, &T_3_3);
        if (locals.err != ERR_ok) goto ex_1;
        locals.mins.num = T_3_3.num;
        }

  LINE(23);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        T_3_1.num = 60;
        locals.err = intOPmod(locals.secs, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.secs.num = T_3_2.num;
        }

  LINE(24);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        T_3_1.num = 60;
        locals.err = intOPdiv(locals.mins, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.err = intOPadd(locals.hours, T_3_2, &T_3_3);
        if (locals.err != ERR_ok) goto ex_1;
        locals.hours.num = T_3_3.num;
        }

  LINE(25);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        T_3_1.num = 60;
        locals.err = intOPmod(locals.mins, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.mins.num = T_3_2.num;
        }

  LINE(26);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        locals.err = intOPdiv(locals.hours, CLU_24, &T_3_1);
        if (locals.err != ERR_ok) goto ex_1;
        locals.err = intOPadd(locals.days, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.days.num = T_3_2.num;
        }

  LINE(27);
        {
        CLUREF T_3_1;
        locals.err = intOPmod(locals.hours, CLU_24, &T_3_1);
        if (locals.err != ERR_ok) goto ex_1;
        locals.hours.num = T_3_1.num;
        }

  LINE(28);
        {
        {
        CLUREF T_3_1;
        RecordAlloc(6, T_3_1);
        T_3_1.vec->data[0]  = locals.days.num;
        T_3_1.vec->data[1]  = locals.hours.num;
        T_3_1.vec->data[4]  = locals.mins.num;
        T_3_1.vec->data[5]  = locals.secs.num;
        T_3_1.vec->data[3]  = locals.millis.num;
        T_3_1.vec->data[2]  = locals.micros.num;
        ret_1->num = T_3_1.num;
        }
        {signal (ERR_ok);}}
        }
    goto end_1;
    ex_1:
        if (locals.err == ERR_overflow) {signal(ERR_overflow);}
        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 create ****/

extern struct OPS *struct_days_hours_micros_millis_mins_secs_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist2 *sigs;
    Vlist8 *locals;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPcreate_actual;
static Vlist1 vals_timeOPcreate = {0, 1, { {0, 2, "", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static sig_desc0 sig_timeOPcreate_1 = {0, 3, "bad_format", {0, 0
}};
static sig_desc0 sig_timeOPcreate_2 = {0, 3, "overflow", {0, 0
}};
static siglist2 sigs_timeOPcreate = {0, 2, (sig_desc*)&sig_timeOPcreate_1, (sig_desc*)&sig_timeOPcreate_2};
static Vlist8 locals_timeOPcreate = {0, 8,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "days", &int_ops},  {0, 2, "hours", &int_ops},  {0, 2, "mins", &int_ops},  {0, 2, "secs", &int_ops},  {0, 2, "millis", &int_ops},  {0, 2, "micros", &int_ops}}
};
static Vlist0 popowns_timeOPcreate = {0, 0};
Slist0 tformals_timeOPcreate = {0, 0};
Slist0 opformals_timeOPcreate = {0, 0};
dbg_info_timeOPcreate_actual dbg_info_timeOPcreate_data = {0, 12, 
    "timeOPcreate", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPcreate, 6, 
    &vals_timeOPcreate, &sigs_timeOPcreate, &locals_timeOPcreate, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPcreate = (struct dbg_info*)&dbg_info_timeOPcreate_data;
extern struct dbg_info* dbg_info_timeOPget_days;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPget_days_TRACE
int timeOPget_days_TRACE;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPget_days_own_init = 0;

/**** BEGIN PROCEDURE get_days ****/

errcode timeOPget_days(t, ret_1)
CLUREF t;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        } locals;
    locals.t.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPget_days;
    locals.t = t;
        if (timeOPget_days_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPget_days_own_init = 1;
    }
    enter_proc(33);

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

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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPget_days_actual;
static Vlist1 vals_timeOPget_days = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_timeOPget_days = {0, 0};
static Vlist3 locals_timeOPget_days = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static Vlist0 popowns_timeOPget_days = {0, 0};
Slist0 tformals_timeOPget_days = {0, 0};
Slist0 opformals_timeOPget_days = {0, 0};
dbg_info_timeOPget_days_actual dbg_info_timeOPget_days_data = {0, 12, 
    "timeOPget_days", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPget_days, 1, 
    &vals_timeOPget_days, &sigs_timeOPget_days, &locals_timeOPget_days, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPget_days = (struct dbg_info*)&dbg_info_timeOPget_days_data;
extern struct dbg_info* dbg_info_timeOPget_hours;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPget_hours_TRACE
int timeOPget_hours_TRACE;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPget_hours_own_init = 0;

/**** BEGIN PROCEDURE get_hours ****/

errcode timeOPget_hours(t, ret_1)
CLUREF t;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        } locals;
    locals.t.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPget_hours;
    locals.t = t;
        if (timeOPget_hours_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPget_hours_own_init = 1;
    }
    enter_proc(37);

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

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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPget_hours_actual;
static Vlist1 vals_timeOPget_hours = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_timeOPget_hours = {0, 0};
static Vlist3 locals_timeOPget_hours = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static Vlist0 popowns_timeOPget_hours = {0, 0};
Slist0 tformals_timeOPget_hours = {0, 0};
Slist0 opformals_timeOPget_hours = {0, 0};
dbg_info_timeOPget_hours_actual dbg_info_timeOPget_hours_data = {0, 12, 
    "timeOPget_hours", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPget_hours, 1, 
    &vals_timeOPget_hours, &sigs_timeOPget_hours, &locals_timeOPget_hours, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPget_hours = (struct dbg_info*)&dbg_info_timeOPget_hours_data;
extern struct dbg_info* dbg_info_timeOPget_minutes;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPget_minutes_TRACE
int timeOPget_minutes_TRACE;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPget_minutes_own_init = 0;

/**** BEGIN PROCEDURE get_minutes ****/

errcode timeOPget_minutes(t, ret_1)
CLUREF t;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        } locals;
    locals.t.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPget_minutes;
    locals.t = t;
        if (timeOPget_minutes_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPget_minutes_own_init = 1;
    }
    enter_proc(41);

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

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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPget_minutes_actual;
static Vlist1 vals_timeOPget_minutes = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_timeOPget_minutes = {0, 0};
static Vlist3 locals_timeOPget_minutes = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static Vlist0 popowns_timeOPget_minutes = {0, 0};
Slist0 tformals_timeOPget_minutes = {0, 0};
Slist0 opformals_timeOPget_minutes = {0, 0};
dbg_info_timeOPget_minutes_actual dbg_info_timeOPget_minutes_data = {0, 12, 
    "timeOPget_minutes", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPget_minutes, 1, 
    &vals_timeOPget_minutes, &sigs_timeOPget_minutes, &locals_timeOPget_minutes, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPget_minutes = (struct dbg_info*)&dbg_info_timeOPget_minutes_data;
extern struct dbg_info* dbg_info_timeOPget_seconds;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPget_seconds_TRACE
int timeOPget_seconds_TRACE;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPget_seconds_own_init = 0;

/**** BEGIN PROCEDURE get_seconds ****/

errcode timeOPget_seconds(t, ret_1)
CLUREF t;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        } locals;
    locals.t.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPget_seconds;
    locals.t = t;
        if (timeOPget_seconds_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPget_seconds_own_init = 1;
    }
    enter_proc(45);

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

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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPget_seconds_actual;
static Vlist1 vals_timeOPget_seconds = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_timeOPget_seconds = {0, 0};
static Vlist3 locals_timeOPget_seconds = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static Vlist0 popowns_timeOPget_seconds = {0, 0};
Slist0 tformals_timeOPget_seconds = {0, 0};
Slist0 opformals_timeOPget_seconds = {0, 0};
dbg_info_timeOPget_seconds_actual dbg_info_timeOPget_seconds_data = {0, 12, 
    "timeOPget_seconds", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPget_seconds, 1, 
    &vals_timeOPget_seconds, &sigs_timeOPget_seconds, &locals_timeOPget_seconds, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPget_seconds = (struct dbg_info*)&dbg_info_timeOPget_seconds_data;
extern struct dbg_info* dbg_info_timeOPget_millis;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPget_millis_TRACE
int timeOPget_millis_TRACE;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPget_millis_own_init = 0;

/**** BEGIN PROCEDURE get_millis ****/

errcode timeOPget_millis(t, ret_1)
CLUREF t;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        } locals;
    locals.t.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPget_millis;
    locals.t = t;
        if (timeOPget_millis_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPget_millis_own_init = 1;
    }
    enter_proc(49);

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

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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPget_millis_actual;
static Vlist1 vals_timeOPget_millis = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_timeOPget_millis = {0, 0};
static Vlist3 locals_timeOPget_millis = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static Vlist0 popowns_timeOPget_millis = {0, 0};
Slist0 tformals_timeOPget_millis = {0, 0};
Slist0 opformals_timeOPget_millis = {0, 0};
dbg_info_timeOPget_millis_actual dbg_info_timeOPget_millis_data = {0, 12, 
    "timeOPget_millis", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPget_millis, 1, 
    &vals_timeOPget_millis, &sigs_timeOPget_millis, &locals_timeOPget_millis, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPget_millis = (struct dbg_info*)&dbg_info_timeOPget_millis_data;
extern struct dbg_info* dbg_info_timeOPget_micros;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPget_micros_TRACE
int timeOPget_micros_TRACE;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPget_micros_own_init = 0;

/**** BEGIN PROCEDURE get_micros ****/

errcode timeOPget_micros(t, ret_1)
CLUREF t;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        } locals;
    locals.t.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPget_micros;
    locals.t = t;
        if (timeOPget_micros_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPget_micros_own_init = 1;
    }
    enter_proc(53);

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

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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPget_micros_actual;
static Vlist1 vals_timeOPget_micros = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_timeOPget_micros = {0, 0};
static Vlist3 locals_timeOPget_micros = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static Vlist0 popowns_timeOPget_micros = {0, 0};
Slist0 tformals_timeOPget_micros = {0, 0};
Slist0 opformals_timeOPget_micros = {0, 0};
dbg_info_timeOPget_micros_actual dbg_info_timeOPget_micros_data = {0, 12, 
    "timeOPget_micros", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPget_micros, 1, 
    &vals_timeOPget_micros, &sigs_timeOPget_micros, &locals_timeOPget_micros, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPget_micros = (struct dbg_info*)&dbg_info_timeOPget_micros_data;
extern struct dbg_info* dbg_info_timeOPget_all;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPget_all_TRACE
int timeOPget_all_TRACE;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPget_all_own_init = 0;

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

errcode timeOPget_all(t, ret_1, ret_2, ret_3, ret_4, ret_5, ret_6)
CLUREF t;
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 t;
        } locals;
    locals.t.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPget_all;
    locals.t = t;
        if (timeOPget_all_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPget_all_own_init = 1;
    }
    enter_proc(57);

  LINE(58);
    {
    {
    CLUREF T_1_1;
    T_1_1.num = locals.t.vec->data[0];
    ret_1->num = T_1_1.num;
    }
    {
    CLUREF T_1_2;
    T_1_2.num = locals.t.vec->data[1];
    ret_2->num = T_1_2.num;
    }
    {
    CLUREF T_1_3;
    T_1_3.num = locals.t.vec->data[4];
    ret_3->num = T_1_3.num;
    }
    {
    CLUREF T_1_4;
    T_1_4.num = locals.t.vec->data[5];
    ret_4->num = T_1_4.num;
    }
    {
    CLUREF T_1_5;
    T_1_5.num = locals.t.vec->data[3];
    ret_5->num = T_1_5.num;
    }
    {
    CLUREF T_1_6;
    T_1_6.num = locals.t.vec->data[2];
    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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPget_all_actual;
static Vlist6 vals_timeOPget_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_timeOPget_all = {0, 0};
static Vlist3 locals_timeOPget_all = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static Vlist0 popowns_timeOPget_all = {0, 0};
Slist0 tformals_timeOPget_all = {0, 0};
Slist0 opformals_timeOPget_all = {0, 0};
dbg_info_timeOPget_all_actual dbg_info_timeOPget_all_data = {0, 12, 
    "timeOPget_all", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPget_all, 1, 
    &vals_timeOPget_all, &sigs_timeOPget_all, &locals_timeOPget_all, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPget_all = (struct dbg_info*)&dbg_info_timeOPget_all_data;
extern struct dbg_info* dbg_info_timeOPadd;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPadd_TRACE
int timeOPadd_TRACE;
extern OWN_req time_ownreqs;
extern struct OPS *time_ops;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPadd_own_init = 0;

/**** BEGIN PROCEDURE add ****/

errcode timeOPadd(t1, t2, ret_1)
CLUREF t1;
CLUREF t2;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF days;
        CLUREF hours;
        CLUREF mins;
        CLUREF secs;
        CLUREF millis;
        CLUREF micros;
        CLUREF t1;
        CLUREF t2;
        } locals;
    locals.days.num = UNINIT;
    locals.hours.num = UNINIT;
    locals.mins.num = UNINIT;
    locals.secs.num = UNINIT;
    locals.millis.num = UNINIT;
    locals.micros.num = UNINIT;
    locals.t1.num = UNINIT;
    locals.t2.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPadd;
    locals.t1 = t1;
    locals.t2 = t2;
        if (timeOPadd_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPadd_own_init = 1;
    }
    enter_proc(61);

  LINE(62);
    {

  LINE(63);
        {
            {CLUREF T_3_1;
            CLUREF T_3_2;
            CLUREF T_3_3;
            CLUREF T_3_4;
            CLUREF T_3_5;
            CLUREF T_3_6;
            locals.err = timeOPget_all(locals.t1, &T_3_1, &T_3_2, &T_3_3, &T_3_4, &T_3_5, &T_3_6);
            if (locals.err != ERR_ok) goto ex_1;
            locals.days.num = T_3_1.num;
            locals.hours.num = T_3_2.num;
            locals.mins.num = T_3_3.num;
            locals.secs.num = T_3_4.num;
            locals.millis.num = T_3_5.num;
            locals.micros.num = T_3_6.num;
            }
            }

  LINE(64);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        T_3_1.num = locals.t2.vec->data[2];
        locals.err = intOPadd(locals.micros, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.micros.num = T_3_2.num;
        }

  LINE(65);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        T_3_1.num = 1000;
        T_3_2.num = (locals.micros.num >= T_3_1.num)? true : false;
        if (T_3_2.num == true) {

  LINE(66);
            {
            CLUREF T_4_1;
            locals.err = intOPadd(locals.millis, CLU_1, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.millis.num = T_4_1.num;
            }

  LINE(67);
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            T_4_1.num = 1000;
            locals.err = intOPsub(locals.micros, T_4_1, &T_4_2);
            if (locals.err != ERR_ok) goto ex_1;
            locals.micros.num = T_4_2.num;
            }
            }
            }/* end if */

  LINE(69);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        T_3_1.num = locals.t2.vec->data[3];
        locals.err = intOPadd(locals.millis, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.millis.num = T_3_2.num;
        }

  LINE(70);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        T_3_1.num = 1000;
        T_3_2.num = (locals.millis.num >= T_3_1.num)? true : false;
        if (T_3_2.num == true) {

  LINE(71);
            {
            CLUREF T_4_1;
            locals.err = intOPadd(locals.secs, CLU_1, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.secs.num = T_4_1.num;
            }

  LINE(72);
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            T_4_1.num = 1000;
            locals.err = intOPsub(locals.millis, T_4_1, &T_4_2);
            if (locals.err != ERR_ok) goto ex_1;
            locals.millis.num = T_4_2.num;
            }
            }
            }/* end if */

  LINE(74);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        T_3_1.num = locals.t2.vec->data[5];
        locals.err = intOPadd(locals.secs, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.secs.num = T_3_2.num;
        }

  LINE(75);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        T_3_1.num = 60;
        T_3_2.num = (locals.secs.num >= T_3_1.num)? true : false;
        if (T_3_2.num == true) {

  LINE(76);
            {
            CLUREF T_4_1;
            locals.err = intOPadd(locals.mins, CLU_1, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.mins.num = T_4_1.num;
            }

  LINE(77);
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            T_4_1.num = 60;
            locals.err = intOPsub(locals.secs, T_4_1, &T_4_2);
            if (locals.err != ERR_ok) goto ex_1;
            locals.secs.num = T_4_2.num;
            }
            }
            }/* end if */

  LINE(79);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        T_3_1.num = locals.t2.vec->data[4];
        locals.err = intOPadd(locals.mins, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.mins.num = T_3_2.num;
        }

  LINE(80);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        T_3_1.num = 60;
        T_3_2.num = (locals.mins.num >= T_3_1.num)? true : false;
        if (T_3_2.num == true) {

  LINE(81);
            {
            CLUREF T_4_1;
            locals.err = intOPadd(locals.hours, CLU_1, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.hours.num = T_4_1.num;
            }

  LINE(82);
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            T_4_1.num = 60;
            locals.err = intOPsub(locals.mins, T_4_1, &T_4_2);
            if (locals.err != ERR_ok) goto ex_1;
            locals.mins.num = T_4_2.num;
            }
            }
            }/* end if */

  LINE(84);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        T_3_1.num = locals.t2.vec->data[1];
        locals.err = intOPadd(locals.hours, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.hours.num = T_3_2.num;
        }

  LINE(85);
        {
        CLUREF T_3_1;
        T_3_1.num = (locals.hours.num >= 24)? true : false;
        if (T_3_1.num == true) {

  LINE(86);
            {
            CLUREF T_4_1;
            locals.err = intOPadd(locals.days, CLU_1, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.days.num = T_4_1.num;
            }

  LINE(87);
            {
            CLUREF T_4_1;
            locals.err = intOPsub(locals.hours, CLU_24, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.hours.num = T_4_1.num;
            }
            }
            }/* end if */

  LINE(89);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        T_3_1.num = locals.t2.vec->data[0];
        locals.err = intOPadd(locals.days, T_3_1, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.days.num = T_3_2.num;
        }

  LINE(90);
        {
        {
        CLUREF T_3_1;
        RecordAlloc(6, T_3_1);
        T_3_1.vec->data[0]  = locals.days.num;
        T_3_1.vec->data[1]  = locals.hours.num;
        T_3_1.vec->data[4]  = locals.mins.num;
        T_3_1.vec->data[5]  = locals.secs.num;
        T_3_1.vec->data[3]  = locals.millis.num;
        T_3_1.vec->data[2]  = locals.micros.num;
        ret_1->num = T_3_1.num;
        }
        {signal (ERR_ok);}}
        }
    goto end_1;
    ex_1:
        if (locals.err == ERR_overflow) {signal(ERR_overflow);}
        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 add ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist10 *locals;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPadd_actual;
static Vlist1 vals_timeOPadd = {0, 1, { {0, 2, "", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static sig_desc0 sig_timeOPadd_1 = {0, 3, "overflow", {0, 0
}};
static siglist1 sigs_timeOPadd = {0, 1, (sig_desc*)&sig_timeOPadd_1};
static Vlist10 locals_timeOPadd = {0, 10,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "days", &int_ops},  {0, 2, "hours", &int_ops},  {0, 2, "mins", &int_ops},  {0, 2, "secs", &int_ops},  {0, 2, "millis", &int_ops},  {0, 2, "micros", &int_ops},  {0, 2, "t1", &time_ops},  {0, 2, "t2", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static Vlist0 popowns_timeOPadd = {0, 0};
Slist0 tformals_timeOPadd = {0, 0};
Slist0 opformals_timeOPadd = {0, 0};
dbg_info_timeOPadd_actual dbg_info_timeOPadd_data = {0, 12, 
    "timeOPadd", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPadd, 2, 
    &vals_timeOPadd, &sigs_timeOPadd, &locals_timeOPadd, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPadd = (struct dbg_info*)&dbg_info_timeOPadd_data;
extern struct dbg_info* dbg_info_timeOPsub;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPsub_TRACE
int timeOPsub_TRACE;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPsub_own_init = 0;

/**** BEGIN PROCEDURE sub ****/

errcode timeOPsub(t1, t2, ret_1)
CLUREF t1;
CLUREF t2;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF days;
        CLUREF hours;
        CLUREF mins;
        CLUREF secs;
        CLUREF millis;
        CLUREF micros;
        CLUREF t1;
        CLUREF t2;
        } locals;
    locals.days.num = UNINIT;
    locals.hours.num = UNINIT;
    locals.mins.num = UNINIT;
    locals.secs.num = UNINIT;
    locals.millis.num = UNINIT;
    locals.micros.num = UNINIT;
    locals.t1.num = UNINIT;
    locals.t2.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPsub;
    locals.t1 = t1;
    locals.t2 = t2;
        if (timeOPsub_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPsub_own_init = 1;
    }
    enter_proc(95);

  LINE(96);
    {
    CLUREF T_1_1;
    locals.err = timeOPgt(locals.t2, locals.t1, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    if (T_1_1.num == true) {

  LINE(97);
        {
        {signal (ERR_negative_time);}}
        }
        }/* end if */

  LINE(98);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        CLUREF T_1_5;
        CLUREF T_1_6;
        locals.err = timeOPget_all(locals.t1, &T_1_1, &T_1_2, &T_1_3, &T_1_4, &T_1_5, &T_1_6);
        if (locals.err != ERR_ok) goto ex_0;
        locals.days.num = T_1_1.num;
        locals.hours.num = T_1_2.num;
        locals.mins.num = T_1_3.num;
        locals.secs.num = T_1_4.num;
        locals.millis.num = T_1_5.num;
        locals.micros.num = T_1_6.num;
        }
        }

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

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

  LINE(101);
        {
        CLUREF T_2_1;
        locals.err = intOPsub(locals.millis, CLU_1, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.millis.num = T_2_1.num;
        }

  LINE(102);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 1000;
        locals.err = intOPadd(locals.micros, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.micros.num = T_2_2.num;
        }
        }
        }/* end if */

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

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

  LINE(106);
        {
        CLUREF T_2_1;
        locals.err = intOPsub(locals.secs, CLU_1, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.secs.num = T_2_1.num;
        }

  LINE(107);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 1000;
        locals.err = intOPadd(locals.millis, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.millis.num = T_2_2.num;
        }
        }
        }/* end if */

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

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

  LINE(111);
        {
        CLUREF T_2_1;
        locals.err = intOPsub(locals.mins, CLU_1, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.mins.num = T_2_1.num;
        }

  LINE(112);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 60;
        locals.err = intOPadd(locals.secs, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.secs.num = T_2_2.num;
        }
        }
        }/* end if */

  LINE(114);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.t2.vec->data[4];
    locals.err = intOPsub(locals.mins, T_1_1, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.mins.num = T_1_2.num;
    }

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

  LINE(116);
        {
        CLUREF T_2_1;
        locals.err = intOPsub(locals.hours, CLU_1, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.hours.num = T_2_1.num;
        }

  LINE(117);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = 60;
        locals.err = intOPadd(locals.mins, T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.mins.num = T_2_2.num;
        }
        }
        }/* end if */

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

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

  LINE(121);
        {
        CLUREF T_2_1;
        locals.err = intOPsub(locals.days, CLU_1, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.days.num = T_2_1.num;
        }

  LINE(122);
        {
        CLUREF T_2_1;
        locals.err = intOPadd(locals.hours, CLU_24, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.hours.num = T_2_1.num;
        }
        }
        }/* end if */

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

  LINE(125);
    {
    {
    CLUREF T_1_1;
    RecordAlloc(6, T_1_1);
    T_1_1.vec->data[0]  = locals.days.num;
    T_1_1.vec->data[1]  = locals.hours.num;
    T_1_1.vec->data[4]  = locals.mins.num;
    T_1_1.vec->data[5]  = locals.secs.num;
    T_1_1.vec->data[3]  = locals.millis.num;
    T_1_1.vec->data[2]  = locals.micros.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 sub ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist10 *locals;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPsub_actual;
static Vlist1 vals_timeOPsub = {0, 1, { {0, 2, "", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static sig_desc0 sig_timeOPsub_1 = {0, 3, "negative_time", {0, 0
}};
static siglist1 sigs_timeOPsub = {0, 1, (sig_desc*)&sig_timeOPsub_1};
static Vlist10 locals_timeOPsub = {0, 10,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "days", &int_ops},  {0, 2, "hours", &int_ops},  {0, 2, "mins", &int_ops},  {0, 2, "secs", &int_ops},  {0, 2, "millis", &int_ops},  {0, 2, "micros", &int_ops},  {0, 2, "t1", &time_ops},  {0, 2, "t2", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static Vlist0 popowns_timeOPsub = {0, 0};
Slist0 tformals_timeOPsub = {0, 0};
Slist0 opformals_timeOPsub = {0, 0};
dbg_info_timeOPsub_actual dbg_info_timeOPsub_data = {0, 12, 
    "timeOPsub", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPsub, 2, 
    &vals_timeOPsub, &sigs_timeOPsub, &locals_timeOPsub, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPsub = (struct dbg_info*)&dbg_info_timeOPsub_data;
extern struct dbg_info* dbg_info_timeOPmul;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPmul_TRACE
int timeOPmul_TRACE;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPmul_own_init = 0;

/**** BEGIN PROCEDURE mul ****/

errcode timeOPmul(t, n, ret_1)
CLUREF t;
CLUREF n;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF days;
        CLUREF hours;
        CLUREF mins;
        CLUREF secs;
        CLUREF millis;
        CLUREF micros;
        CLUREF carry;
        CLUREF t;
        CLUREF n;
        } locals;
    locals.days.num = UNINIT;
    locals.hours.num = UNINIT;
    locals.mins.num = UNINIT;
    locals.secs.num = UNINIT;
    locals.millis.num = UNINIT;
    locals.micros.num = UNINIT;
    locals.carry.num = UNINIT;
    locals.t.num = UNINIT;
    locals.n.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPmul;
    locals.t = t;
    locals.n = n;
        if (timeOPmul_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPmul_own_init = 1;
    }
    enter_proc(129);

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

  LINE(132);
        {
        {signal (ERR_negative_multiplier);}}
        }
        }/* end if */

  LINE(133);
    {

  LINE(134);
        locals.days.num = UNINIT;
        locals.hours.num = UNINIT;
        locals.mins.num = UNINIT;
        locals.secs.num = UNINIT;
        locals.millis.num = UNINIT;
        locals.micros.num = UNINIT;
        locals.carry.num = UNINIT;

  LINE(135);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        CLUREF T_3_4;
        T_3_1.num = locals.t.vec->data[2];
        T_3_2.num = 1000;
        locals.err = timeOPdo_div(CLU_0, T_3_1, locals.n, T_3_2, &T_3_3, &T_3_4);
        if (locals.err != ERR_ok) goto ex_1;
        locals.carry.num = T_3_3.num;
        locals.micros.num = T_3_4.num;
        }

  LINE(136);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        CLUREF T_3_4;
        T_3_1.num = locals.t.vec->data[3];
        T_3_2.num = 1000;
        locals.err = timeOPdo_div(locals.carry, T_3_1, locals.n, T_3_2, &T_3_3, &T_3_4);
        if (locals.err != ERR_ok) goto ex_1;
        locals.carry.num = T_3_3.num;
        locals.millis.num = T_3_4.num;
        }

  LINE(137);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        CLUREF T_3_4;
        T_3_1.num = locals.t.vec->data[5];
        T_3_2.num = 60;
        locals.err = timeOPdo_div(locals.carry, T_3_1, locals.n, T_3_2, &T_3_3, &T_3_4);
        if (locals.err != ERR_ok) goto ex_1;
        locals.carry.num = T_3_3.num;
        locals.secs.num = T_3_4.num;
        }

  LINE(138);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        CLUREF T_3_4;
        T_3_1.num = locals.t.vec->data[4];
        T_3_2.num = 60;
        locals.err = timeOPdo_div(locals.carry, T_3_1, locals.n, T_3_2, &T_3_3, &T_3_4);
        if (locals.err != ERR_ok) goto ex_1;
        locals.carry.num = T_3_3.num;
        locals.mins.num = T_3_4.num;
        }

  LINE(139);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        T_3_1.num = locals.t.vec->data[1];
        locals.err = timeOPdo_div(locals.carry, T_3_1, locals.n, CLU_24, &T_3_2, &T_3_3);
        if (locals.err != ERR_ok) goto ex_1;
        locals.carry.num = T_3_2.num;
        locals.hours.num = T_3_3.num;
        }

  LINE(140);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        T_3_1.num = locals.t.vec->data[0];
        locals.err = intOPmul(T_3_1, locals.n, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.err = intOPadd(T_3_2, locals.carry, &T_3_3);
        if (locals.err != ERR_ok) goto ex_1;
        locals.days.num = T_3_3.num;
        }

  LINE(141);
        {
        {
        CLUREF T_3_1;
        RecordAlloc(6, T_3_1);
        T_3_1.vec->data[0]  = locals.days.num;
        T_3_1.vec->data[1]  = locals.hours.num;
        T_3_1.vec->data[4]  = locals.mins.num;
        T_3_1.vec->data[5]  = locals.secs.num;
        T_3_1.vec->data[3]  = locals.millis.num;
        T_3_1.vec->data[2]  = locals.micros.num;
        ret_1->num = T_3_1.num;
        }
        {signal (ERR_ok);}}
        }
    goto end_1;
    ex_1:
        if (locals.err == ERR_overflow) {signal(ERR_overflow);}
        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 mul ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist2 *sigs;
    Vlist11 *locals;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPmul_actual;
static Vlist1 vals_timeOPmul = {0, 1, { {0, 2, "", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static sig_desc0 sig_timeOPmul_1 = {0, 3, "negative_multiplier", {0, 0
}};
static sig_desc0 sig_timeOPmul_2 = {0, 3, "overflow", {0, 0
}};
static siglist2 sigs_timeOPmul = {0, 2, (sig_desc*)&sig_timeOPmul_1, (sig_desc*)&sig_timeOPmul_2};
static Vlist11 locals_timeOPmul = {0, 11,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "days", &int_ops},  {0, 2, "hours", &int_ops},  {0, 2, "mins", &int_ops},  {0, 2, "secs", &int_ops},  {0, 2, "millis", &int_ops},  {0, 2, "micros", &int_ops},  {0, 2, "carry", &int_ops},  {0, 2, "t", &struct_days_hours_micros_millis_mins_secs_ops},  {0, 2, "n", &int_ops}}
};
static Vlist0 popowns_timeOPmul = {0, 0};
Slist0 tformals_timeOPmul = {0, 0};
Slist0 opformals_timeOPmul = {0, 0};
dbg_info_timeOPmul_actual dbg_info_timeOPmul_data = {0, 12, 
    "timeOPmul", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPmul, 2, 
    &vals_timeOPmul, &sigs_timeOPmul, &locals_timeOPmul, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPmul = (struct dbg_info*)&dbg_info_timeOPmul_data;
extern struct dbg_info* dbg_info_timeOPdiv;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPdiv_TRACE
int timeOPdiv_TRACE;
static int timeOPdiv_own_init = 0;

/**** BEGIN PROCEDURE div ****/

errcode timeOPdiv(t, n, ret_1)
CLUREF t;
CLUREF n;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        CLUREF n;
        } locals;
    locals.t.num = UNINIT;
    locals.n.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPdiv;
    locals.t = t;
    locals.n = n;
        if (timeOPdiv_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPdiv_own_init = 1;
    }
    enter_proc(146);

  LINE(147);
    {
    {
    CLUREF T_2_1;
    locals.err = timeOPaverage(locals.t, locals.n, &T_2_1);
    if (locals.err != ERR_ok) goto ex_1;
    ret_1->num = T_2_1.num;
    }
    {signal (ERR_ok);}}
    goto end_1;
    ex_1:
        if (locals.err == ERR_bad_divisor) {signal(ERR_bad_divisor);}
        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 div ****/

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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPdiv_actual;
static Vlist1 vals_timeOPdiv = {0, 1, { {0, 2, "", &time_ops}}
};
static sig_desc0 sig_timeOPdiv_1 = {0, 3, "bad_divisor", {0, 0
}};
static siglist1 sigs_timeOPdiv = {0, 1, (sig_desc*)&sig_timeOPdiv_1};
static Vlist4 locals_timeOPdiv = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &time_ops},  {0, 2, "n", &int_ops}}
};
static Vlist0 popowns_timeOPdiv = {0, 0};
Slist0 tformals_timeOPdiv = {0, 0};
Slist0 opformals_timeOPdiv = {0, 0};
dbg_info_timeOPdiv_actual dbg_info_timeOPdiv_data = {0, 12, 
    "timeOPdiv", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPdiv, 2, 
    &vals_timeOPdiv, &sigs_timeOPdiv, &locals_timeOPdiv, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPdiv = (struct dbg_info*)&dbg_info_timeOPdiv_data;
extern struct dbg_info* dbg_info_timeOPaverage;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPaverage_TRACE
int timeOPaverage_TRACE;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPaverage_own_init = 0;

/**** BEGIN PROCEDURE average ****/

errcode timeOPaverage(t, n, ret_1)
CLUREF t;
CLUREF n;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF days;
        CLUREF hours;
        CLUREF mins;
        CLUREF secs;
        CLUREF millis;
        CLUREF micros;
        CLUREF rem;
        CLUREF i;
        CLUREF t;
        CLUREF n;
        } locals;
    locals.days.num = UNINIT;
    locals.hours.num = UNINIT;
    locals.mins.num = UNINIT;
    locals.secs.num = UNINIT;
    locals.millis.num = UNINIT;
    locals.micros.num = UNINIT;
    locals.rem.num = UNINIT;
    locals.i.num = UNINIT;
    locals.t.num = UNINIT;
    locals.n.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPaverage;
    locals.t = t;
    locals.n = n;
        if (timeOPaverage_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPaverage_own_init = 1;
    }
    enter_proc(151);

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

  LINE(153);
        {
        {signal (ERR_bad_divisor);}}
        }
        }/* end if */

  LINE(154);
    locals.days.num = UNINIT;
    locals.hours.num = UNINIT;
    locals.mins.num = UNINIT;
    locals.secs.num = UNINIT;
    locals.millis.num = UNINIT;
    locals.micros.num = UNINIT;
    locals.rem.num = UNINIT;

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

  LINE(156);
    {
    CLUREF T_1_1;
    locals.err = intOPdiv(locals.i, locals.n, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    locals.days.num = T_1_1.num;
    }

  LINE(157);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.t.vec->data[1];
    locals.err = intOPmod(locals.i, locals.n, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = timeOPdo_div(T_1_1, CLU_24, T_1_2, locals.n, &T_1_3, &T_1_4);
    if (locals.err != ERR_ok) goto ex_0;
    locals.hours.num = T_1_3.num;
    locals.rem.num = T_1_4.num;
    }

  LINE(158);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.t.vec->data[4];
    T_1_2.num = 60;
    locals.err = timeOPdo_div(T_1_1, T_1_2, locals.rem, locals.n, &T_1_3, &T_1_4);
    if (locals.err != ERR_ok) goto ex_0;
    locals.mins.num = T_1_3.num;
    locals.rem.num = T_1_4.num;
    }

  LINE(159);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.t.vec->data[5];
    T_1_2.num = 60;
    locals.err = timeOPdo_div(T_1_1, T_1_2, locals.rem, locals.n, &T_1_3, &T_1_4);
    if (locals.err != ERR_ok) goto ex_0;
    locals.secs.num = T_1_3.num;
    locals.rem.num = T_1_4.num;
    }

  LINE(160);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.t.vec->data[3];
    T_1_2.num = 1000;
    locals.err = timeOPdo_div(T_1_1, T_1_2, locals.rem, locals.n, &T_1_3, &T_1_4);
    if (locals.err != ERR_ok) goto ex_0;
    locals.millis.num = T_1_3.num;
    locals.rem.num = T_1_4.num;
    }

  LINE(161);
    {
    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_1.num = locals.t.vec->data[2];
    locals.err = intOPdiv(locals.n, CLU_2, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = intOPadd(T_1_1, T_1_2, &T_1_3);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_4.num = 1000;
    locals.err = timeOPdo_div(T_1_3, T_1_4, locals.rem, locals.n, &T_1_5, &T_1_6);
    if (locals.err != ERR_ok) goto ex_0;
    locals.micros.num = T_1_5.num;
    locals.rem.num = T_1_6.num;
    }

  LINE(162);
    {
    {
    CLUREF T_1_1;
    RecordAlloc(6, T_1_1);
    T_1_1.vec->data[0]  = locals.days.num;
    T_1_1.vec->data[1]  = locals.hours.num;
    T_1_1.vec->data[4]  = locals.mins.num;
    T_1_1.vec->data[5]  = locals.secs.num;
    T_1_1.vec->data[3]  = locals.millis.num;
    T_1_1.vec->data[2]  = locals.micros.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 average ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist1 *sigs;
    Vlist12 *locals;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPaverage_actual;
static Vlist1 vals_timeOPaverage = {0, 1, { {0, 2, "", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static sig_desc0 sig_timeOPaverage_1 = {0, 3, "bad_divisor", {0, 0
}};
static siglist1 sigs_timeOPaverage = {0, 1, (sig_desc*)&sig_timeOPaverage_1};
static Vlist12 locals_timeOPaverage = {0, 12,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "days", &int_ops},  {0, 2, "hours", &int_ops},  {0, 2, "mins", &int_ops},  {0, 2, "secs", &int_ops},  {0, 2, "millis", &int_ops},  {0, 2, "micros", &int_ops},  {0, 2, "rem", &int_ops},  {0, 2, "i", &int_ops},  {0, 2, "t", &struct_days_hours_micros_millis_mins_secs_ops},  {0, 2, "n", &int_ops}}
};
static Vlist0 popowns_timeOPaverage = {0, 0};
Slist0 tformals_timeOPaverage = {0, 0};
Slist0 opformals_timeOPaverage = {0, 0};
dbg_info_timeOPaverage_actual dbg_info_timeOPaverage_data = {0, 12, 
    "timeOPaverage", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPaverage, 2, 
    &vals_timeOPaverage, &sigs_timeOPaverage, &locals_timeOPaverage, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPaverage = (struct dbg_info*)&dbg_info_timeOPaverage_data;
extern struct dbg_info* dbg_info_timeOPdo_div;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPdo_div_TRACE
int timeOPdo_div_TRACE;
extern errcode timeOPdo_div_IB_1();
static int timeOPdo_div_own_init = 0;

/**** BEGIN PROCEDURE do_div ****/

errcode timeOPdo_div(a, b, c, d, ret_1, ret_2)
CLUREF a;
CLUREF b;
CLUREF c;
CLUREF d;
CLUREF *ret_1;
CLUREF *ret_2;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        CLUREF q;
        CLUREF r;
        CLUREF rr;
        CLUREF i;
        CLUREF x;
        CLUREF a;
        CLUREF b;
        CLUREF c;
        CLUREF d;
        } locals;
    locals.t.num = UNINIT;
    locals.q.num = UNINIT;
    locals.r.num = UNINIT;
    locals.rr.num = UNINIT;
    locals.i.num = UNINIT;
    locals.x.num = UNINIT;
    locals.a.num = UNINIT;
    locals.b.num = UNINIT;
    locals.c.num = UNINIT;
    locals.d.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPdo_div;
    locals.a = a;
    locals.b = b;
    locals.c = c;
    locals.d = d;
        if (timeOPdo_div_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPdo_div_own_init = 1;
    }
    enter_proc(168);

  LINE(169);
    {

  LINE(170);
        {
            {CLUREF T_3_1;
            CLUREF T_3_2;
            locals.err = intOPmul(locals.b, locals.c, &T_3_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.err = intOPadd(locals.a, T_3_1, &T_3_2);
            if (locals.err != ERR_ok) goto ex_1;
            locals.t.num = T_3_2.num;
            }
            }

  LINE(171);
        {
        {
        CLUREF T_3_1;
        locals.err = intOPdiv(locals.t, locals.d, &T_3_1);
        if (locals.err != ERR_ok) goto ex_1;
        ret_1->num = T_3_1.num;
        }
        {
        CLUREF T_3_2;
        locals.err = intOPmod(locals.t, locals.d, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        ret_2->num = T_3_2.num;
        }
        {signal (ERR_ok);}}
        }
        goto end_1;
        ex_1:
            if ((locals.err == ERR_overflow)) {
            }
            else {
                goto ex_0;
            }
        end_1:;

  LINE(173);
    {
        {CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        locals.err = intOPdiv(locals.a, locals.d, &T_2_1);
        if (locals.err != ERR_ok) goto ex_2;
        locals.err = intOPdiv(locals.c, locals.d, &T_2_2);
        if (locals.err != ERR_ok) goto ex_2;
        locals.err = intOPmul(locals.b, T_2_2, &T_2_3);
        if (locals.err != ERR_ok) goto ex_2;
        locals.err = intOPadd(T_2_1, T_2_3, &T_2_4);
        if (locals.err != ERR_ok) goto ex_2;
        locals.q.num = T_2_4.num;
        }
        }
    goto end_2;
    ex_2:
        if (locals.err == ERR_overflow) {signal(ERR_overflow);}
        else {
            goto ex_0;}
    end_2:;

  LINE(175);
    {
        {CLUREF T_1_1;
        locals.err = intOPmod(locals.a, locals.d, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.r.num = T_1_1.num;
        }
        }

  LINE(176);
    {
        {CLUREF T_1_1;
        locals.err = intOPmod(locals.c, locals.d, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.rr.num = T_1_1.num;
        }
        }

  LINE(177);
    {
        locals.err = intOPfrom_to(CLU_1, locals.b, timeOPdo_div_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        ret_1->num = elist[0].num;
        ret_2->num = elist[1].num;
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_3;
        }
    goto end_3;
    ex_3:
        if (locals.err == ERR_overflow) {signal(ERR_overflow);}
        else {
            goto ex_0;}
    end_3:;

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

/**** END PROCEDURE do_div ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist2 *vals;
    siglist1 *sigs;
    Vlist12 *locals;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPdo_div_actual;
static Vlist2 vals_timeOPdo_div = {0, 2, { {0, 2, "", &int_ops},  {0, 2, "", &int_ops}}
};
static sig_desc0 sig_timeOPdo_div_1 = {0, 3, "overflow", {0, 0
}};
static siglist1 sigs_timeOPdo_div = {0, 1, (sig_desc*)&sig_timeOPdo_div_1};
static Vlist12 locals_timeOPdo_div = {0, 12,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &int_ops},  {0, 2, "q", &int_ops},  {0, 2, "r", &int_ops},  {0, 2, "rr", &int_ops},  {0, 2, "i", &int_ops},  {0, 2, "x", &int_ops},  {0, 2, "a", &int_ops},  {0, 2, "b", &int_ops},  {0, 2, "c", &int_ops},  {0, 2, "d", &int_ops}}
};
static Vlist0 popowns_timeOPdo_div = {0, 0};
Slist0 tformals_timeOPdo_div = {0, 0};
Slist0 opformals_timeOPdo_div = {0, 0};
dbg_info_timeOPdo_div_actual dbg_info_timeOPdo_div_data = {0, 12, 
    "timeOPdo_div", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPdo_div, 4, 
    &vals_timeOPdo_div, &sigs_timeOPdo_div, &locals_timeOPdo_div, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPdo_div = (struct dbg_info*)&dbg_info_timeOPdo_div_data;

/**** BEGIN ITERATOR BODIES for do_div ****/

errcode timeOPdo_div_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 t;
    CLUREF q;
    CLUREF r;
    CLUREF rr;
    CLUREF i;
    CLUREF x;
    CLUREF a;
    CLUREF b;
    CLUREF c;
    CLUREF d;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(178);

  FB_LINE(178);
    {
        {CLUREF T_1_1;
        locals->err = intOPsub(locals->d, locals->r, &T_1_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->x.num = T_1_1.num;
        }
        }

  FB_LINE(179);
    {
    CLUREF T_1_1;
    T_1_1.num = (locals->rr.num >= locals->x.num)? true : false;
    if (T_1_1.num == true) {

  FB_LINE(180);
        {
        CLUREF T_2_1;
        locals->err = intOPsub(locals->rr, locals->x, &T_2_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->r.num = T_2_1.num;
        }

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

  FB_LINE(182);
        {
        CLUREF T_2_1;
        locals->err = intOPadd(locals->r, locals->rr, &T_2_1);
        if (locals->err != ERR_ok) goto ex_0;
        locals->r.num = T_2_1.num;
        }
        }}/* end if */
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end timeOPdo_div_IB_1 */

/**** END ITERATOR BODIES for do_div ****/

extern struct dbg_info* dbg_info_timeOPlt;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPlt_TRACE
int timeOPlt_TRACE;
extern OWN_req bool_ownreqs;
extern struct OPS *bool_ops;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPlt_own_init = 0;

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

errcode timeOPlt(t1, t2, ret_1)
CLUREF t1;
CLUREF t2;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t1;
        CLUREF t2;
        } locals;
    locals.t1.num = UNINIT;
    locals.t2.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPlt;
    locals.t1 = t1;
    locals.t2 = t2;
        if (timeOPlt_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPlt_own_init = 1;
    }
    enter_proc(188);

  LINE(189);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = locals.t1.vec->data[0];
    T_1_2.num = locals.t2.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(190);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.t1.vec->data[0];
        T_2_2.num = locals.t2.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);}}
        }
    else {
    CLUREF T_1_5;
    CLUREF T_1_6;
    CLUREF T_1_7;
    CLUREF T_1_8;
    T_1_5.num = locals.t1.vec->data[1];
    T_1_6.num = locals.t2.vec->data[1];
    T_1_7.num = (T_1_5.num == T_1_6.num)? true : false;
    T_1_8.num = T_1_7.num ^ 1;
    if (T_1_8.num == true) {

  LINE(192);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.t1.vec->data[1];
        T_2_2.num = locals.t2.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);}}
        }
    else {
    CLUREF T_1_9;
    CLUREF T_1_10;
    CLUREF T_1_11;
    CLUREF T_1_12;
    T_1_9.num = locals.t1.vec->data[4];
    T_1_10.num = locals.t2.vec->data[4];
    T_1_11.num = (T_1_9.num == T_1_10.num)? true : false;
    T_1_12.num = T_1_11.num ^ 1;
    if (T_1_12.num == true) {

  LINE(194);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.t1.vec->data[4];
        T_2_2.num = locals.t2.vec->data[4];
        T_2_3.num = (T_2_1.num < T_2_2.num)? true : false;
        ret_1->num = T_2_3.num;
        }
        {signal (ERR_ok);}}
        }
    else {
    CLUREF T_1_13;
    CLUREF T_1_14;
    CLUREF T_1_15;
    CLUREF T_1_16;
    T_1_13.num = locals.t1.vec->data[5];
    T_1_14.num = locals.t2.vec->data[5];
    T_1_15.num = (T_1_13.num == T_1_14.num)? true : false;
    T_1_16.num = T_1_15.num ^ 1;
    if (T_1_16.num == true) {

  LINE(196);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.t1.vec->data[5];
        T_2_2.num = locals.t2.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);}}
        }
    else {
    CLUREF T_1_17;
    CLUREF T_1_18;
    CLUREF T_1_19;
    CLUREF T_1_20;
    T_1_17.num = locals.t1.vec->data[3];
    T_1_18.num = locals.t2.vec->data[3];
    T_1_19.num = (T_1_17.num == T_1_18.num)? true : false;
    T_1_20.num = T_1_19.num ^ 1;
    if (T_1_20.num == true) {

  LINE(198);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.t1.vec->data[3];
        T_2_2.num = locals.t2.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);}}
        }
    else {

  LINE(199);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = locals.t1.vec->data[2];
        T_2_2.num = locals.t2.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 */
    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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPlt_actual;
static Vlist1 vals_timeOPlt = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_timeOPlt = {0, 0};
static Vlist4 locals_timeOPlt = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t1", &struct_days_hours_micros_millis_mins_secs_ops},  {0, 2, "t2", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static Vlist0 popowns_timeOPlt = {0, 0};
Slist0 tformals_timeOPlt = {0, 0};
Slist0 opformals_timeOPlt = {0, 0};
dbg_info_timeOPlt_actual dbg_info_timeOPlt_data = {0, 12, 
    "timeOPlt", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPlt, 2, 
    &vals_timeOPlt, &sigs_timeOPlt, &locals_timeOPlt, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPlt = (struct dbg_info*)&dbg_info_timeOPlt_data;
extern struct dbg_info* dbg_info_timeOPle;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPle_TRACE
int timeOPle_TRACE;
static int timeOPle_own_init = 0;

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

errcode timeOPle(t1, t2, ret_1)
CLUREF t1;
CLUREF t2;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t1;
        CLUREF t2;
        } locals;
    locals.t1.num = UNINIT;
    locals.t2.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPle;
    locals.t1 = t1;
    locals.t2 = t2;
        if (timeOPle_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPle_own_init = 1;
    }
    enter_proc(202);

  LINE(203);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    locals.err = timeOPlt(locals.t1, locals.t2, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_1.num = T_1_2.num;
    if (!T_1_2.num) {
        locals.err = timeOPequal(locals.t1, locals.t2, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        T_1_1.num = T_1_3.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 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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPle_actual;
static Vlist1 vals_timeOPle = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_timeOPle = {0, 0};
static Vlist4 locals_timeOPle = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t1", &time_ops},  {0, 2, "t2", &time_ops}}
};
static Vlist0 popowns_timeOPle = {0, 0};
Slist0 tformals_timeOPle = {0, 0};
Slist0 opformals_timeOPle = {0, 0};
dbg_info_timeOPle_actual dbg_info_timeOPle_data = {0, 12, 
    "timeOPle", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPle, 2, 
    &vals_timeOPle, &sigs_timeOPle, &locals_timeOPle, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPle = (struct dbg_info*)&dbg_info_timeOPle_data;
extern struct dbg_info* dbg_info_timeOPge;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPge_TRACE
int timeOPge_TRACE;
static int timeOPge_own_init = 0;

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

errcode timeOPge(t1, t2, ret_1)
CLUREF t1;
CLUREF t2;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t1;
        CLUREF t2;
        } locals;
    locals.t1.num = UNINIT;
    locals.t2.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPge;
    locals.t1 = t1;
    locals.t2 = t2;
        if (timeOPge_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPge_own_init = 1;
    }
    enter_proc(206);

  LINE(207);
    {
    {
    CLUREF T_1_1;
    locals.err = timeOPle(locals.t2, locals.t1, &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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPge_actual;
static Vlist1 vals_timeOPge = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_timeOPge = {0, 0};
static Vlist4 locals_timeOPge = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t1", &time_ops},  {0, 2, "t2", &time_ops}}
};
static Vlist0 popowns_timeOPge = {0, 0};
Slist0 tformals_timeOPge = {0, 0};
Slist0 opformals_timeOPge = {0, 0};
dbg_info_timeOPge_actual dbg_info_timeOPge_data = {0, 12, 
    "timeOPge", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPge, 2, 
    &vals_timeOPge, &sigs_timeOPge, &locals_timeOPge, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPge = (struct dbg_info*)&dbg_info_timeOPge_data;
extern struct dbg_info* dbg_info_timeOPgt;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPgt_TRACE
int timeOPgt_TRACE;
static int timeOPgt_own_init = 0;

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

errcode timeOPgt(t1, t2, ret_1)
CLUREF t1;
CLUREF t2;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t1;
        CLUREF t2;
        } locals;
    locals.t1.num = UNINIT;
    locals.t2.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPgt;
    locals.t1 = t1;
    locals.t2 = t2;
        if (timeOPgt_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPgt_own_init = 1;
    }
    enter_proc(210);

  LINE(211);
    {
    {
    CLUREF T_1_1;
    locals.err = timeOPlt(locals.t2, locals.t1, &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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPgt_actual;
static Vlist1 vals_timeOPgt = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_timeOPgt = {0, 0};
static Vlist4 locals_timeOPgt = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t1", &time_ops},  {0, 2, "t2", &time_ops}}
};
static Vlist0 popowns_timeOPgt = {0, 0};
Slist0 tformals_timeOPgt = {0, 0};
Slist0 opformals_timeOPgt = {0, 0};
dbg_info_timeOPgt_actual dbg_info_timeOPgt_data = {0, 12, 
    "timeOPgt", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPgt, 2, 
    &vals_timeOPgt, &sigs_timeOPgt, &locals_timeOPgt, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPgt = (struct dbg_info*)&dbg_info_timeOPgt_data;
extern struct dbg_info* dbg_info_timeOPparse;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPparse_TRACE
int timeOPparse_TRACE;
struct OPS *array_of_int_table;
struct OPS *array_of_int_ops;
struct OPS *array_of_int_ops;
OWNPTR array_of_int_owns;
static int timeOPparse_own_init = 0;

/**** BEGIN PROCEDURE parse ****/

errcode timeOPparse(s, ret_1)
CLUREF s;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF a;
        CLUREF i;
        CLUREF s;
        } locals;
    locals.a.num = UNINIT;
    locals.i.num = UNINIT;
    locals.s.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPparse;
    locals.s = s;
        if (timeOPparse_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPparse_own_init = 1;
    }
    enter_proc(217);

  LINE(219);
    {

  LINE(220);
        {
            {CLUREF T_3_1;
            locals.err = arrayOPpredict(CLU_1, CLU_6, &T_3_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.a.num = T_3_1.num;
            }
            }

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

  LINE(222);
            {
                {CLUREF T_4_1;
                CLUREF T_4_2;
                T_4_1.ch = ':';
                locals.err = stringOPindexc(T_4_1, locals.s, &T_4_2);
                if (locals.err != ERR_ok) goto ex_1;
                locals.i.num = T_4_2.num;
                }
                }

  LINE(223);
            {
            CLUREF T_4_1;
            T_4_1.num = (locals.i.num == 0)? true : false;
            if (T_4_1.num == true) {

  LINE(224);
                goto end_while_1;
                }
                }/* end if */

  LINE(225);
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            CLUREF T_4_3;
            locals.err = intOPsub(locals.i, CLU_1, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.err = stringOPsubstr(locals.s, CLU_1, T_4_1, &T_4_2);
            if (locals.err != ERR_ok) goto ex_1;
            locals.err = intOPparse(T_4_2, &T_4_3);
            if (locals.err != ERR_ok) goto ex_1;
            locals.err = arrayOPaddh(locals.a, T_4_3);
            if (locals.err != ERR_ok) goto ex_1;
            }

  LINE(226);
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            locals.err = intOPadd(locals.i, CLU_1, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.err = stringOPrest(locals.s, T_4_1, &T_4_2);
            if (locals.err != ERR_ok) goto ex_1;
            locals.s.num = T_4_2.num;
            }
            }
            end_while_1:;

  LINE(228);
        {
            {CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.ch = '.';
            locals.err = stringOPindexc(T_3_1, locals.s, &T_3_2);
            if (locals.err != ERR_ok) goto ex_1;
            locals.i.num = T_3_2.num;
            }
            }

  LINE(229);
        {
        CLUREF T_3_1;
        T_3_1.num = (locals.i.num > 0)? true : false;
        if (T_3_1.num == true) {

  LINE(230);
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            CLUREF T_4_3;
            locals.err = intOPsub(locals.i, CLU_1, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.err = stringOPsubstr(locals.s, CLU_1, T_4_1, &T_4_2);
            if (locals.err != ERR_ok) goto ex_1;
            locals.err = intOPparse(T_4_2, &T_4_3);
            if (locals.err != ERR_ok) goto ex_1;
            locals.err = arrayOPaddh(locals.a, T_4_3);
            if (locals.err != ERR_ok) goto ex_1;
            }

  LINE(231);
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            locals.err = intOPadd(locals.i, CLU_1, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.err = stringOPrest(locals.s, T_4_1, &T_4_2);
            if (locals.err != ERR_ok) goto ex_1;
            locals.s.num = T_4_2.num;
            }
            }
        else {

  LINE(232);
            {
            CLUREF T_4_1;
            locals.err = intOPparse(locals.s, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.err = arrayOPaddh(locals.a, T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            }

  LINE(233);
            {
            locals.s = STR_;
            }
            }}/* end if */

  LINE(235);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        T_3_1.num = locals.a.array->ext_size;
        T_3_2.num = (T_3_1.num > 4)? true : false;
        if (T_3_2.num == true) {

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

  LINE(237);
        for (;;) {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.a.array->ext_size;
            T_3_2.num = (T_3_1.num < 4)? true : false;
            if (T_3_2.num != true) { break; }

  LINE(238);
            {
            locals.err = arrayOPaddl(locals.a, CLU_0);
            if (locals.err != ERR_ok) goto ex_1;
            }
            }
            end_while_2:;

  LINE(240);
        for (;;) {
            CLUREF T_3_1;
            CLUREF T_3_2;
            CLUREF T_3_3;
            CLUREF T_3_4;
            locals.err = stringOPsize(locals.s, &T_3_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.err = intOPmod(T_3_1, CLU_3, &T_3_2);
            if (locals.err != ERR_ok) goto ex_1;
            T_3_3.num = (T_3_2.num == 0)? true : false;
            T_3_4.num = T_3_3.num ^ 1;
            if (T_3_4.num != true) { break; }

  LINE(241);
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            T_4_1.ch = '0';
            locals.err = stringOPappend(locals.s, T_4_1, &T_4_2);
            if (locals.err != ERR_ok) goto ex_1;
            locals.s.num = T_4_2.num;
            }
            }
            end_while_3:;

  LINE(243);
        for (;;) {
            CLUREF T_3_1;
            CLUREF T_3_2;
            locals.err = stringOPempty(locals.s, &T_3_1);
            if (locals.err != ERR_ok) goto ex_1;
            T_3_2.num = T_3_1.num ^ 1;
            if (T_3_2.num != true) { break; }

  LINE(244);
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            locals.err = stringOPsubstr(locals.s, CLU_1, CLU_3, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.err = intOPparse(T_4_1, &T_4_2);
            if (locals.err != ERR_ok) goto ex_1;
            locals.err = arrayOPaddh(locals.a, T_4_2);
            if (locals.err != ERR_ok) goto ex_1;
            }

  LINE(245);
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            locals.err = stringOPsize(locals.s, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            T_4_2.num = (T_4_1.num <= 3)? true : false;
            if (T_4_2.num == true) {

  LINE(246);
                goto end_while_4;
                }
                }/* end if */

  LINE(247);
            {
            CLUREF T_4_1;
            locals.err = stringOPrest(locals.s, CLU_4, &T_4_1);
            if (locals.err != ERR_ok) goto ex_1;
            locals.s.num = T_4_1.num;
            }
            }
            end_while_4:;

  LINE(249);
        for (;;) {
            CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = locals.a.array->ext_size;
            T_3_2.num = (T_3_1.num < 6)? true : false;
            if (T_3_2.num != true) { break; }

  LINE(250);
            {
            locals.err = arrayOPaddh(locals.a, CLU_0);
            if (locals.err != ERR_ok) goto ex_1;
            }
            }
            end_while_5:;

  LINE(252);
        {
        locals.err = arrayOPset_low(locals.a, CLU_1);
        if (locals.err != ERR_ok) goto ex_1;
        }

  LINE(253);
        {
        {
        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 = arrayOPfetch(locals.a, CLU_1, &T_3_1);
        if (locals.err != ERR_ok) goto ex_1;
        locals.err = arrayOPfetch(locals.a, CLU_2, &T_3_2);
        if (locals.err != ERR_ok) goto ex_1;
        locals.err = arrayOPfetch(locals.a, CLU_3, &T_3_3);
        if (locals.err != ERR_ok) goto ex_1;
        locals.err = arrayOPfetch(locals.a, CLU_4, &T_3_4);
        if (locals.err != ERR_ok) goto ex_1;
        locals.err = arrayOPfetch(locals.a, CLU_5, &T_3_5);
        if (locals.err != ERR_ok) goto ex_1;
        locals.err = arrayOPfetch(locals.a, CLU_6, &T_3_6);
        if (locals.err != ERR_ok) goto ex_1;
        locals.err = timeOPcreate(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_1;
        ret_1->num = T_3_7.num;
        }
        {signal (ERR_ok);}}
        }
        goto end_1;
        ex_1:
            if ((locals.err == ERR_overflow)) {

  LINE(254);
                {
                {signal (ERR_overflow);}}
            }
            else {

  LINE(255);
                {
                {signal (ERR_bad_format);}}
            }
        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 parse ****/

extern struct OPS *array_of_int_ops;
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;
    siglist2 *sigs;
    Vlist5 *locals;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPparse_actual;
static Vlist1 vals_timeOPparse = {0, 1, { {0, 2, "", &time_ops}}
};
static sig_desc0 sig_timeOPparse_1 = {0, 3, "bad_format", {0, 0
}};
static sig_desc0 sig_timeOPparse_2 = {0, 3, "overflow", {0, 0
}};
static siglist2 sigs_timeOPparse = {0, 2, (sig_desc*)&sig_timeOPparse_1, (sig_desc*)&sig_timeOPparse_2};
static Vlist5 locals_timeOPparse = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &array_of_int_ops},  {0, 2, "i", &int_ops},  {0, 2, "s", &string_ops}}
};
static Vlist0 popowns_timeOPparse = {0, 0};
Slist0 tformals_timeOPparse = {0, 0};
Slist0 opformals_timeOPparse = {0, 0};
dbg_info_timeOPparse_actual dbg_info_timeOPparse_data = {0, 12, 
    "timeOPparse", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPparse, 1, 
    &vals_timeOPparse, &sigs_timeOPparse, &locals_timeOPparse, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPparse = (struct dbg_info*)&dbg_info_timeOPparse_data;
extern struct dbg_info* dbg_info_timeOPunparse;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPunparse_TRACE
int timeOPunparse_TRACE;
static int timeOPunparse_own_init = 0;

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

errcode timeOPunparse(t, ret_1)
CLUREF t;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        } locals;
    locals.t.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPunparse;
    locals.t = t;
        if (timeOPunparse_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPunparse_own_init = 1;
    }
    enter_proc(259);

  LINE(260);
    {
    {
    CLUREF T_1_1;
    locals.err = timeOPformat(locals.t, CLU_6, &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 unparse ****/

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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPunparse_actual;
static Vlist1 vals_timeOPunparse = {0, 1, { {0, 2, "", &string_ops}}
};
static siglist0 sigs_timeOPunparse = {0, 0};
static Vlist3 locals_timeOPunparse = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &time_ops}}
};
static Vlist0 popowns_timeOPunparse = {0, 0};
Slist0 tformals_timeOPunparse = {0, 0};
Slist0 opformals_timeOPunparse = {0, 0};
dbg_info_timeOPunparse_actual dbg_info_timeOPunparse_data = {0, 12, 
    "timeOPunparse", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPunparse, 1, 
    &vals_timeOPunparse, &sigs_timeOPunparse, &locals_timeOPunparse, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPunparse = (struct dbg_info*)&dbg_info_timeOPunparse_data;
extern struct dbg_info* dbg_info_timeOPt2r;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPt2r_TRACE
int timeOPt2r_TRACE;
extern OWN_req real_ownreqs;
extern struct OPS *real_ops;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPt2r_own_init = 0;

/**** BEGIN PROCEDURE t2r ****/

errcode timeOPt2r(t, ret_1)
CLUREF t;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        } locals;
    locals.t.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPt2r;
    locals.t = t;
        if (timeOPt2r_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPt2r_own_init = 1;
    }
    enter_proc(265);

  LINE(266);
    {
    {
    CLUREF T_2_1;
    CLUREF T_2_2;
    CLUREF T_2_3;
    CLUREF T_2_4;
    CLUREF T_2_5;
    CLUREF T_2_6;
    CLUREF T_2_7;
    CLUREF T_2_8;
    CLUREF T_2_9;
    CLUREF T_2_10;
    CLUREF T_2_11;
    CLUREF T_2_12;
    CLUREF T_2_13;
    CLUREF T_2_14;
    CLUREF T_2_15;
    CLUREF T_2_16;
    CLUREF T_2_17;
    CLUREF T_2_18;
    CLUREF T_2_19;
    CLUREF T_2_20;
    CLUREF T_2_21;
    CLUREF T_2_22;
    CLUREF T_2_23;
    CLUREF T_2_24;
    CLUREF T_2_25;
    CLUREF T_2_26;
    CLUREF T_2_27;
    T_2_1.num = locals.t.vec->data[2];
    locals.err = realOPi2r(T_2_1, &T_2_2);
    if (locals.err != ERR_ok) goto ex_1;
    T_2_3.real = 1.000000e+06;
    locals.err = realOPdiv(T_2_2, T_2_3, &T_2_4);
    if (locals.err != ERR_ok) goto ex_1;
    T_2_5.num = locals.t.vec->data[3];
    locals.err = realOPi2r(T_2_5, &T_2_6);
    if (locals.err != ERR_ok) goto ex_1;
    T_2_7.real = 1.000000e+03;
    locals.err = realOPdiv(T_2_6, T_2_7, &T_2_8);
    if (locals.err != ERR_ok) goto ex_1;
    locals.err = realOPadd(T_2_4, T_2_8, &T_2_9);
    if (locals.err != ERR_ok) goto ex_1;
    T_2_10.num = locals.t.vec->data[5];
    locals.err = realOPi2r(T_2_10, &T_2_11);
    if (locals.err != ERR_ok) goto ex_1;
    locals.err = realOPadd(T_2_9, T_2_11, &T_2_12);
    if (locals.err != ERR_ok) goto ex_1;
    T_2_13.num = locals.t.vec->data[4];
    locals.err = realOPi2r(T_2_13, &T_2_14);
    if (locals.err != ERR_ok) goto ex_1;
    T_2_15.real = 6.000000e+01;
    locals.err = realOPmul(T_2_14, T_2_15, &T_2_16);
    if (locals.err != ERR_ok) goto ex_1;
    locals.err = realOPadd(T_2_12, T_2_16, &T_2_17);
    if (locals.err != ERR_ok) goto ex_1;
    T_2_18.num = locals.t.vec->data[1];
    locals.err = realOPi2r(T_2_18, &T_2_19);
    if (locals.err != ERR_ok) goto ex_1;
    T_2_20.real = 3.600000e+03;
    locals.err = realOPmul(T_2_19, T_2_20, &T_2_21);
    if (locals.err != ERR_ok) goto ex_1;
    locals.err = realOPadd(T_2_17, T_2_21, &T_2_22);
    if (locals.err != ERR_ok) goto ex_1;
    T_2_23.num = locals.t.vec->data[0];
    locals.err = realOPi2r(T_2_23, &T_2_24);
    if (locals.err != ERR_ok) goto ex_1;
    T_2_25.real = 8.640000e+04;
    locals.err = realOPmul(T_2_24, T_2_25, &T_2_26);
    if (locals.err != ERR_ok) goto ex_1;
    locals.err = realOPadd(T_2_22, T_2_26, &T_2_27);
    if (locals.err != ERR_ok) goto ex_1;
    ret_1->num = T_2_27.num;
    }
    {signal (ERR_ok);}}
    goto end_1;
    ex_1:
        if (locals.err == ERR_overflow) {signal(ERR_overflow);}
        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 t2r ****/

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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPt2r_actual;
static Vlist1 vals_timeOPt2r = {0, 1, { {0, 2, "", &real_ops}}
};
static sig_desc0 sig_timeOPt2r_1 = {0, 3, "overflow", {0, 0
}};
static siglist1 sigs_timeOPt2r = {0, 1, (sig_desc*)&sig_timeOPt2r_1};
static Vlist3 locals_timeOPt2r = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static Vlist0 popowns_timeOPt2r = {0, 0};
Slist0 tformals_timeOPt2r = {0, 0};
Slist0 opformals_timeOPt2r = {0, 0};
dbg_info_timeOPt2r_actual dbg_info_timeOPt2r_data = {0, 12, 
    "timeOPt2r", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPt2r, 1, 
    &vals_timeOPt2r, &sigs_timeOPt2r, &locals_timeOPt2r, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPt2r = (struct dbg_info*)&dbg_info_timeOPt2r_data;
extern struct dbg_info* dbg_info_timeOPformat;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPformat_TRACE
int timeOPformat_TRACE;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPformat_own_init = 0;

/**** BEGIN PROCEDURE format ****/

errcode timeOPformat(t, frac_width, ret_1)
CLUREF t;
CLUREF frac_width;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF s;
        CLUREF b;
        CLUREF frac;
        CLUREF t;
        CLUREF frac_width;
        } locals;
    locals.s.num = UNINIT;
    locals.b.num = UNINIT;
    locals.frac.num = UNINIT;
    locals.t.num = UNINIT;
    locals.frac_width.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPformat;
    locals.t = t;
    locals.frac_width = frac_width;
        if (timeOPformat_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPformat_own_init = 1;
    }
    enter_proc(279);

  LINE(280);
    locals.s.num = UNINIT;

  LINE(281);
    {
        {locals.b.tf = false;
        }
        }

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

  LINE(283);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        T_2_1.num = locals.t.vec->data[0];
        locals.err = intOPunparse(T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        T_2_3.ch = ':';
        locals.err = stringOPappend(T_2_2, T_2_3, &T_2_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.s.num = T_2_4.num;
        }

  LINE(284);
        {
        locals.b.tf = true;
        }
        }
        }/* end if */

  LINE(286);
    {
    if (locals.b.num == true) {

  LINE(287);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        CLUREF T_2_5;
        CLUREF T_2_6;
        CLUREF T_2_7;
        CLUREF T_2_8;
        T_2_1.num = locals.t.vec->data[1];
        T_2_2.num = 100;
        locals.err = intOPadd(T_2_1, T_2_2, &T_2_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPunparse(T_2_3, &T_2_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = stringOPrest(T_2_4, CLU_2, &T_2_5);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = stringOPconcat(locals.s, T_2_5, &T_2_6);
        if (locals.err != ERR_ok) goto ex_0;
        T_2_7.ch = ':';
        locals.err = stringOPappend(T_2_6, T_2_7, &T_2_8);
        if (locals.err != ERR_ok) goto ex_0;
        locals.s.num = T_2_8.num;
        }
        }
    else {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.t.vec->data[1];
    T_1_2.num = (T_1_1.num > 0)? true : false;
    if (T_1_2.num == true) {

  LINE(290);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        T_2_1.num = locals.t.vec->data[1];
        locals.err = intOPunparse(T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        T_2_3.ch = ':';
        locals.err = stringOPappend(T_2_2, T_2_3, &T_2_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.s.num = T_2_4.num;
        }

  LINE(291);
        {
        locals.b.tf = true;
        }
        }
        }}/* end if */

  LINE(293);
    {
    if (locals.b.num == true) {

  LINE(294);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        CLUREF T_2_5;
        CLUREF T_2_6;
        CLUREF T_2_7;
        CLUREF T_2_8;
        T_2_1.num = locals.t.vec->data[4];
        T_2_2.num = 100;
        locals.err = intOPadd(T_2_1, T_2_2, &T_2_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPunparse(T_2_3, &T_2_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = stringOPrest(T_2_4, CLU_2, &T_2_5);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = stringOPconcat(locals.s, T_2_5, &T_2_6);
        if (locals.err != ERR_ok) goto ex_0;
        T_2_7.ch = ':';
        locals.err = stringOPappend(T_2_6, T_2_7, &T_2_8);
        if (locals.err != ERR_ok) goto ex_0;
        locals.s.num = T_2_8.num;
        }
        }
    else {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = locals.t.vec->data[4];
    T_1_2.num = (T_1_1.num > 0)? true : false;
    if (T_1_2.num == true) {

  LINE(297);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        T_2_1.num = locals.t.vec->data[4];
        locals.err = intOPunparse(T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        T_2_3.ch = ':';
        locals.err = stringOPappend(T_2_2, T_2_3, &T_2_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.s.num = T_2_4.num;
        }

  LINE(298);
        {
        locals.b.tf = true;
        }
        }
        }}/* end if */

  LINE(300);
    {
    if (locals.b.num == true) {

  LINE(301);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        CLUREF T_2_4;
        CLUREF T_2_5;
        CLUREF T_2_6;
        T_2_1.num = locals.t.vec->data[5];
        T_2_2.num = 100;
        locals.err = intOPadd(T_2_1, T_2_2, &T_2_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPunparse(T_2_3, &T_2_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = stringOPrest(T_2_4, CLU_2, &T_2_5);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = stringOPconcat(locals.s, T_2_5, &T_2_6);
        if (locals.err != ERR_ok) goto ex_0;
        locals.s.num = T_2_6.num;
        }
        }
    else {

  LINE(302);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        T_2_1.num = locals.t.vec->data[5];
        locals.err = intOPunparse(T_2_1, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.s.num = T_2_2.num;
        }
        }}/* end if */

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

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

  LINE(306);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        T_1_1.num = locals.t.vec->data[3];
        T_1_2.num = 1000;
        locals.err = intOPadd(T_1_1, T_1_2, &T_1_3);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = intOPunparse(T_1_3, &T_1_4);
        if (locals.err != ERR_ok) goto ex_0;
        locals.frac.num = T_1_4.num;
        }
        }

  LINE(307);
    {
    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_1.num = locals.t.vec->data[2];
    T_1_2.num = 1000;
    locals.err = intOPadd(T_1_1, T_1_2, &T_1_3);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = intOPunparse(T_1_3, &T_1_4);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = stringOPrest(T_1_4, CLU_2, &T_1_5);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = stringOPconcat(locals.frac, T_1_5, &T_1_6);
    if (locals.err != ERR_ok) goto ex_0;
    locals.frac.num = T_1_6.num;
    }

  LINE(308);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.ch = '.';
    locals.err = stringOPappend(locals.s, T_1_1, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = stringOPsubstr(locals.frac, CLU_2, locals.frac_width, &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 format ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist7 *locals;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPformat_actual;
static Vlist1 vals_timeOPformat = {0, 1, { {0, 2, "", &string_ops}}
};
static siglist0 sigs_timeOPformat = {0, 0};
static Vlist7 locals_timeOPformat = {0, 7,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "s", &string_ops},  {0, 2, "b", &bool_ops},  {0, 2, "frac", &string_ops},  {0, 2, "t", &struct_days_hours_micros_millis_mins_secs_ops},  {0, 2, "frac_width", &int_ops}}
};
static Vlist0 popowns_timeOPformat = {0, 0};
Slist0 tformals_timeOPformat = {0, 0};
Slist0 opformals_timeOPformat = {0, 0};
dbg_info_timeOPformat_actual dbg_info_timeOPformat_data = {0, 12, 
    "timeOPformat", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPformat, 2, 
    &vals_timeOPformat, &sigs_timeOPformat, &locals_timeOPformat, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPformat = (struct dbg_info*)&dbg_info_timeOPformat_data;
extern struct dbg_info* dbg_info_timeOPprint;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPprint_TRACE
int timeOPprint_TRACE;
extern OWN_req pstream_ownreqs;
extern struct OPS *pstream_ops;
static int timeOPprint_own_init = 0;

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

errcode timeOPprint(t, pst)
CLUREF t;
CLUREF pst;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        CLUREF pst;
        } locals;
    locals.t.num = UNINIT;
    locals.pst.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPprint;
    locals.t = t;
    locals.pst = pst;
        if (timeOPprint_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPprint_own_init = 1;
    }
    enter_proc(311);

  LINE(312);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    locals.err = timeOPunparse(locals.t, &T_1_1);
    if (locals.err != ERR_ok) goto ex_0;
    locals.err = pstreamOPtext(locals.pst, 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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPprint_actual;
static Vlist0 vals_timeOPprint = {0, 0};
static siglist0 sigs_timeOPprint = {0, 0};
static Vlist4 locals_timeOPprint = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &time_ops},  {0, 2, "pst", &pstream_ops}}
};
static Vlist0 popowns_timeOPprint = {0, 0};
Slist0 tformals_timeOPprint = {0, 0};
Slist0 opformals_timeOPprint = {0, 0};
dbg_info_timeOPprint_actual dbg_info_timeOPprint_data = {0, 12, 
    "timeOPprint", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPprint, 2, 
    &vals_timeOPprint, &sigs_timeOPprint, &locals_timeOPprint, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPprint = (struct dbg_info*)&dbg_info_timeOPprint_data;
extern struct dbg_info* dbg_info_timeOPequal;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPequal_TRACE
int timeOPequal_TRACE;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPequal_own_init = 0;

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

errcode timeOPequal(t1, t2, ret_1)
CLUREF t1;
CLUREF t2;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t1;
        CLUREF t2;
        } locals;
    locals.t1.num = UNINIT;
    locals.t2.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPequal;
    locals.t1 = t1;
    locals.t2 = t2;
        if (timeOPequal_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPequal_own_init = 1;
    }
    enter_proc(315);

  LINE(316);
    {

  LINE(317);
        {
        {
        CLUREF T_2_1;
        generic_CLU_proc.type_owns = 0;
        generic_CLU_proc.op_owns = struct_days_hours_micros_millis_mins_secs_ops->entry[0].fcn->op_owns;
        generic_CLU_proc.proc = structOPequal;
        CUR_PROC_VAR.proc = &generic_CLU_proc;
        locals.err = structOPequal(locals.t1, locals.t2, &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 ****/

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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPequal_actual;
static Vlist1 vals_timeOPequal = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_timeOPequal = {0, 0};
static Vlist4 locals_timeOPequal = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t1", &struct_days_hours_micros_millis_mins_secs_ops},  {0, 2, "t2", &struct_days_hours_micros_millis_mins_secs_ops}}
};
static Vlist0 popowns_timeOPequal = {0, 0};
Slist0 tformals_timeOPequal = {0, 0};
Slist0 opformals_timeOPequal = {0, 0};
dbg_info_timeOPequal_actual dbg_info_timeOPequal_data = {0, 12, 
    "timeOPequal", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPequal, 2, 
    &vals_timeOPequal, &sigs_timeOPequal, &locals_timeOPequal, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPequal = (struct dbg_info*)&dbg_info_timeOPequal_data;
extern struct dbg_info* dbg_info_timeOPsimilar;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPsimilar_TRACE
int timeOPsimilar_TRACE;
static int timeOPsimilar_own_init = 0;

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

errcode timeOPsimilar(t1, t2, ret_1)
CLUREF t1;
CLUREF t2;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t1;
        CLUREF t2;
        } locals;
    locals.t1.num = UNINIT;
    locals.t2.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPsimilar;
    locals.t1 = t1;
    locals.t2 = t2;
        if (timeOPsimilar_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPsimilar_own_init = 1;
    }
    enter_proc(321);

  LINE(322);
    {
    {
    CLUREF T_1_1;
    locals.err = timeOPequal(locals.t1, locals.t2, &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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPsimilar_actual;
static Vlist1 vals_timeOPsimilar = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_timeOPsimilar = {0, 0};
static Vlist4 locals_timeOPsimilar = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t1", &time_ops},  {0, 2, "t2", &time_ops}}
};
static Vlist0 popowns_timeOPsimilar = {0, 0};
Slist0 tformals_timeOPsimilar = {0, 0};
Slist0 opformals_timeOPsimilar = {0, 0};
dbg_info_timeOPsimilar_actual dbg_info_timeOPsimilar_data = {0, 12, 
    "timeOPsimilar", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPsimilar, 2, 
    &vals_timeOPsimilar, &sigs_timeOPsimilar, &locals_timeOPsimilar, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPsimilar = (struct dbg_info*)&dbg_info_timeOPsimilar_data;
extern struct dbg_info* dbg_info_timeOPcopy;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPcopy_TRACE
int timeOPcopy_TRACE;

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

errcode timeOPcopy(t, ret_1)
CLUREF t;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        } locals;
    locals.t.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPcopy;
    locals.t = t;
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
    enter_proc(325);

  LINE(326);
    {
    {
    ret_1->num = locals.t.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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPcopy_actual;
static Vlist1 vals_timeOPcopy = {0, 1, { {0, 2, "", &time_ops}}
};
static siglist0 sigs_timeOPcopy = {0, 0};
static Vlist3 locals_timeOPcopy = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &time_ops}}
};
static Vlist0 popowns_timeOPcopy = {0, 0};
Slist0 tformals_timeOPcopy = {0, 0};
Slist0 opformals_timeOPcopy = {0, 0};
dbg_info_timeOPcopy_actual dbg_info_timeOPcopy_data = {0, 12, 
    "timeOPcopy", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPcopy, 1, 
    &vals_timeOPcopy, &sigs_timeOPcopy, &locals_timeOPcopy, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPcopy = (struct dbg_info*)&dbg_info_timeOPcopy_data;
extern struct dbg_info* dbg_info_timeOPencode;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPencode_TRACE
int timeOPencode_TRACE;
extern OWN_req string_ownreqs;
static int timeOPencode_own_init = 0;

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

errcode timeOPencode(t, ist)
CLUREF t;
CLUREF ist;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        CLUREF ist;
        } locals;
    locals.t.num = UNINIT;
    locals.ist.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOPencode;
    locals.t = t;
    locals.ist = ist;
        if (timeOPencode_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPencode_own_init = 1;
    }
    enter_proc(329);

  LINE(330);
    {
    CLUREF T_2_1;
    locals.err = timeOPunparse(locals.t, &T_2_1);
    if (locals.err != ERR_ok) goto ex_1;
    locals.err = stringOPencode(T_2_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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPencode_actual;
static Vlist0 vals_timeOPencode = {0, 0};
static sig_desc1 sig_timeOPencode_1 = {0, 4, "not_possible", {0, 1
, { {0, 2, "", &string_ops}}}};
static siglist1 sigs_timeOPencode = {0, 1, (sig_desc*)&sig_timeOPencode_1};
static Vlist4 locals_timeOPencode = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &time_ops},  {0, 2, "ist", &istream_ops}}
};
static Vlist0 popowns_timeOPencode = {0, 0};
Slist0 tformals_timeOPencode = {0, 0};
Slist0 opformals_timeOPencode = {0, 0};
dbg_info_timeOPencode_actual dbg_info_timeOPencode_data = {0, 12, 
    "timeOPencode", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPencode, 2, 
    &vals_timeOPencode, &sigs_timeOPencode, &locals_timeOPencode, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPencode = (struct dbg_info*)&dbg_info_timeOPencode_data;
extern struct dbg_info* dbg_info_timeOPdecode;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPdecode_TRACE
int timeOPdecode_TRACE;
static int timeOPdecode_own_init = 0;

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

errcode timeOPdecode(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_timeOPdecode;
    locals.ist = ist;
        if (timeOPdecode_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPdecode_own_init = 1;
    }
    enter_proc(334);

  LINE(336);
    {
    {
    CLUREF T_3_1;
    CLUREF T_3_2;
    locals.err = stringOPdecode(locals.ist, &T_3_1);
    if (locals.err != ERR_ok) goto ex_2;
    locals.err = timeOPparse(T_3_1, &T_3_2);
    if (locals.err != ERR_ok) goto ex_2;
    ret_1->num = T_3_2.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(338);
                {
                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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPdecode_actual;
static Vlist1 vals_timeOPdecode = {0, 1, { {0, 2, "", &time_ops}}
};
static sig_desc0 sig_timeOPdecode_1 = {0, 3, "end_of_file", {0, 0
}};
static sig_desc1 sig_timeOPdecode_2 = {0, 4, "not_possible", {0, 1
, { {0, 2, "", &string_ops}}}};
static siglist2 sigs_timeOPdecode = {0, 2, (sig_desc*)&sig_timeOPdecode_1, (sig_desc*)&sig_timeOPdecode_2};
static Vlist3 locals_timeOPdecode = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "ist", &istream_ops}}
};
static Vlist0 popowns_timeOPdecode = {0, 0};
Slist0 tformals_timeOPdecode = {0, 0};
Slist0 opformals_timeOPdecode = {0, 0};
dbg_info_timeOPdecode_actual dbg_info_timeOPdecode_data = {0, 12, 
    "timeOPdecode", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPdecode, 1, 
    &vals_timeOPdecode, &sigs_timeOPdecode, &locals_timeOPdecode, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPdecode = (struct dbg_info*)&dbg_info_timeOPdecode_data;
extern struct dbg_info* dbg_info_timeOP_gcd;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOP_gcd_TRACE
int timeOP_gcd_TRACE;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOP_gcd_own_init = 0;

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

errcode timeOP_gcd(t, tab, ret_1)
CLUREF t;
CLUREF tab;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF t;
        CLUREF tab;
        } locals;
    locals.t.num = UNINIT;
    locals.tab.num = UNINIT;
    locals.DBG_INFO = dbg_info_timeOP_gcd;
    locals.t = t;
    locals.tab = tab;
        if (timeOP_gcd_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOP_gcd_own_init = 1;
    }
    enter_proc(341);

  LINE(342);
    {
    {
    CLUREF T_1_1;
    generic_CLU_proc.type_owns = 0;
    generic_CLU_proc.op_owns = struct_days_hours_micros_millis_mins_secs_ops->entry[6].fcn->op_owns;
    generic_CLU_proc.proc = structOP_gcd;
    CUR_PROC_VAR.proc = &generic_CLU_proc;
    locals.err = structOP_gcd(locals.t, 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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOP_gcd_actual;
static Vlist1 vals_timeOP_gcd = {0, 1, { {0, 2, "", &int_ops}}
};
static siglist0 sigs_timeOP_gcd = {0, 0};
static Vlist4 locals_timeOP_gcd = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "t", &struct_days_hours_micros_millis_mins_secs_ops},  {0, 2, "tab", &gcd_tab_ops}}
};
static Vlist0 popowns_timeOP_gcd = {0, 0};
Slist0 tformals_timeOP_gcd = {0, 0};
Slist0 opformals_timeOP_gcd = {0, 0};
dbg_info_timeOP_gcd_actual dbg_info_timeOP_gcd_data = {0, 12, 
    "timeOP_gcd", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOP_gcd, 2, 
    &vals_timeOP_gcd, &sigs_timeOP_gcd, &locals_timeOP_gcd, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOP_gcd = (struct dbg_info*)&dbg_info_timeOP_gcd_data;
extern struct dbg_info* dbg_info_timeOPdebug_print;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG timeOPdebug_print_TRACE
int timeOPdebug_print_TRACE;
struct OPS  *struct_days_hours_micros_millis_mins_secs_ops;
static int timeOPdebug_print_own_init = 0;

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

errcode timeOPdebug_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_timeOPdebug_print;
    locals._rep = _rep;
    locals.ps = ps;
        if (timeOPdebug_print_own_init == 0) {
        if (time_own_init == 0) {
            locals.err = time_own_init_proc();
            if (locals.err != ERR_ok) goto ex_0;
            }
        timeOPdebug_print_own_init = 1;
    }
    enter_proc(1);

  LINE(2);
    {
    locals.err = timeOPprint(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;
    Vlist31 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_timeOPdebug_print_actual;
static Vlist0 vals_timeOPdebug_print = {0, 0};
static siglist0 sigs_timeOPdebug_print = {0, 0};
static Vlist4 locals_timeOPdebug_print = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "_rep", &struct_days_hours_micros_millis_mins_secs_ops},  {0, 2, "ps", &pstream_ops}}
};
static Vlist0 popowns_timeOPdebug_print = {0, 0};
Slist0 tformals_timeOPdebug_print = {0, 0};
Slist0 opformals_timeOPdebug_print = {0, 0};
dbg_info_timeOPdebug_print_actual dbg_info_timeOPdebug_print_data = {0, 12, 
    "timeOPdebug_print", "/common/pub/dcurtis-temp/pclu/lib/clu/time.clu", 0, 0, (int)timeOPdebug_print, 2, 
    &vals_timeOPdebug_print, &sigs_timeOPdebug_print, &locals_timeOPdebug_print, &owns_time, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_timeOPdebug_print = (struct dbg_info*)&dbg_info_timeOPdebug_print_data;
typedef struct{
    int count;
    OWNPTR type_owns;
    OWNPTR op_owns;
    struct OP_ENTRY entry[29];
} time_OPS;

CLU_proc time_oe__gcd = {{0,0,0,0}, timeOP_gcd, 0};
CLU_proc time_oe_add = {{0,0,0,0}, timeOPadd, 0};
CLU_proc time_oe_average = {{0,0,0,0}, timeOPaverage, 0};
CLU_proc time_oe_copy = {{0,0,0,0}, timeOPcopy, 0};
CLU_proc time_oe_create = {{0,0,0,0}, timeOPcreate, 0};
CLU_proc time_oe_decode = {{0,0,0,0}, timeOPdecode, 0};
CLU_proc time_oe_div = {{0,0,0,0}, timeOPdiv, 0};
CLU_proc time_oe_encode = {{0,0,0,0}, timeOPencode, 0};
CLU_proc time_oe_equal = {{0,0,0,0}, timeOPequal, 0};
CLU_proc time_oe_format = {{0,0,0,0}, timeOPformat, 0};
CLU_proc time_oe_ge = {{0,0,0,0}, timeOPge, 0};
CLU_proc time_oe_get_all = {{0,0,0,0}, timeOPget_all, 0};
CLU_proc time_oe_get_days = {{0,0,0,0}, timeOPget_days, 0};
CLU_proc time_oe_get_hours = {{0,0,0,0}, timeOPget_hours, 0};
CLU_proc time_oe_get_micros = {{0,0,0,0}, timeOPget_micros, 0};
CLU_proc time_oe_get_millis = {{0,0,0,0}, timeOPget_millis, 0};
CLU_proc time_oe_get_minutes = {{0,0,0,0}, timeOPget_minutes, 0};
CLU_proc time_oe_get_seconds = {{0,0,0,0}, timeOPget_seconds, 0};
CLU_proc time_oe_gt = {{0,0,0,0}, timeOPgt, 0};
CLU_proc time_oe_le = {{0,0,0,0}, timeOPle, 0};
CLU_proc time_oe_lt = {{0,0,0,0}, timeOPlt, 0};
CLU_proc time_oe_mul = {{0,0,0,0}, timeOPmul, 0};
CLU_proc time_oe_parse = {{0,0,0,0}, timeOPparse, 0};
CLU_proc time_oe_print = {{0,0,0,0}, timeOPprint, 0};
CLU_proc time_oe_similar = {{0,0,0,0}, timeOPsimilar, 0};
CLU_proc time_oe_sub = {{0,0,0,0}, timeOPsub, 0};
CLU_proc time_oe_t2r = {{0,0,0,0}, timeOPt2r, 0};
CLU_proc time_oe_unparse = {{0,0,0,0}, timeOPunparse, 0};
CLU_proc time_oe_debug_print = {{0,0,0,0}, timeOPdebug_print, 0};

time_OPS time_ops_actual = {29, (OWNPTR)&time_own_init, (OWNPTR)&time_own_init, {
    {&time_oe__gcd, "_gcd"},
    {&time_oe_add, "add"},
    {&time_oe_average, "average"},
    {&time_oe_copy, "copy"},
    {&time_oe_create, "create"},
    {&time_oe_decode, "decode"},
    {&time_oe_div, "div"},
    {&time_oe_encode, "encode"},
    {&time_oe_equal, "equal"},
    {&time_oe_format, "format"},
    {&time_oe_ge, "ge"},
    {&time_oe_get_all, "get_all"},
    {&time_oe_get_days, "get_days"},
    {&time_oe_get_hours, "get_hours"},
    {&time_oe_get_micros, "get_micros"},
    {&time_oe_get_millis, "get_millis"},
    {&time_oe_get_minutes, "get_minutes"},
    {&time_oe_get_seconds, "get_seconds"},
    {&time_oe_gt, "gt"},
    {&time_oe_le, "le"},
    {&time_oe_lt, "lt"},
    {&time_oe_mul, "mul"},
    {&time_oe_parse, "parse"},
    {&time_oe_print, "print"},
    {&time_oe_similar, "similar"},
    {&time_oe_sub, "sub"},
    {&time_oe_t2r, "t2r"},
    {&time_oe_unparse, "unparse"},
    {&time_oe_debug_print, "debug_print"}}};

struct OPS *time_ops = (struct OPS *)&time_ops_actual;

/**** END CLUSTER time ****/