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

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


extern struct dbg_info* dbg_info_padl;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG padl_TRACE
int padl_TRACE;
extern struct OPS *int_ops;
static Vlist1 owns_padl = {0, 1,{ {0, 2, "_init", &int_ops}
}
};
extern errcode padlc();

/**** BEGIN PROCEDURE padl ****/

errcode padl(s, w, ret_1)
CLUREF s;
CLUREF w;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF s;
        CLUREF w;
        } locals;
    locals.s.num = UNINIT;
    locals.w.num = UNINIT;
    locals.DBG_INFO = dbg_info_padl;
    locals.s = s;
    locals.w = w;
    enter_proc(20);

  LINE(21);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.ch = ' ';
    locals.err = padlc(locals.s, locals.w, T_1_1, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_2.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE padl ****/

extern struct OPS *string_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist4 *locals;
    Vlist1 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_padl_actual;
static Vlist1 vals_padl = {0, 1, { {0, 2, "", &string_ops}}
};
static siglist0 sigs_padl = {0, 0};
static Vlist4 locals_padl = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "s", &string_ops},  {0, 2, "w", &int_ops}}
};
static Vlist0 popowns_padl = {0, 0};
Slist0 tformals_padl = {0, 0};
Slist0 opformals_padl = {0, 0};
dbg_info_padl_actual dbg_info_padl_data = {0, 12, 
    "padl", "/common/pub/dcurtis-temp/pclu/lib/clu/string_ops.clu", 0, 0, (int)padl, 2, 
    &vals_padl, &sigs_padl, &locals_padl, &owns_padl, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_padl = (struct dbg_info*)&dbg_info_padl_data;

extern struct dbg_info* dbg_info_padr;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG padr_TRACE
int padr_TRACE;
static Vlist1 owns_padr = {0, 1,{ {0, 2, "_init", &int_ops}
}
};
extern errcode padrc();

/**** BEGIN PROCEDURE padr ****/

errcode padr(s, w, ret_1)
CLUREF s;
CLUREF w;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF s;
        CLUREF w;
        } locals;
    locals.s.num = UNINIT;
    locals.w.num = UNINIT;
    locals.DBG_INFO = dbg_info_padr;
    locals.s = s;
    locals.w = w;
    enter_proc(24);

  LINE(25);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.ch = ' ';
    locals.err = padrc(locals.s, locals.w, T_1_1, &T_1_2);
    if (locals.err != ERR_ok) goto ex_0;
    ret_1->num = T_1_2.num;
    }
    {signal (ERR_ok);}}
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE padr ****/

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;
    Vlist1 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_padr_actual;
static Vlist1 vals_padr = {0, 1, { {0, 2, "", &string_ops}}
};
static siglist0 sigs_padr = {0, 0};
static Vlist4 locals_padr = {0, 4,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "s", &string_ops},  {0, 2, "w", &int_ops}}
};
static Vlist0 popowns_padr = {0, 0};
Slist0 tformals_padr = {0, 0};
Slist0 opformals_padr = {0, 0};
dbg_info_padr_actual dbg_info_padr_data = {0, 12, 
    "padr", "/common/pub/dcurtis-temp/pclu/lib/clu/string_ops.clu", 0, 0, (int)padr, 2, 
    &vals_padr, &sigs_padr, &locals_padr, &owns_padr, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_padr = (struct dbg_info*)&dbg_info_padr_data;

extern struct dbg_info* dbg_info_padlc;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG padlc_TRACE
int padlc_TRACE;
static Vlist1 owns_padlc = {0, 1,{ {0, 2, "_init", &int_ops}
}
};
extern errcode stringOPc2s();
extern errcode intOPlt();
extern errcode stringOPsize();
extern errcode stringOPconcat();
extern OWN_req string_ownreqs;
static int padlc_own_init = 0;

/**** BEGIN PROCEDURE padlc ****/

errcode padlc(s, w, c, ret_1)
CLUREF s;
CLUREF w;
CLUREF c;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF cs;
        CLUREF s;
        CLUREF w;
        CLUREF c;
        } locals;
    locals.cs.num = UNINIT;
    locals.s.num = UNINIT;
    locals.w.num = UNINIT;
    locals.c.num = UNINIT;
    locals.DBG_INFO = dbg_info_padlc;
    locals.s = s;
    locals.w = w;
    locals.c = c;
        if (padlc_own_init == 0) {
        padlc_own_init = 1;
    }
    enter_proc(28);

  LINE(29);
    {
        {CLUREF T_1_1;
        locals.err = stringOPc2s(locals.c, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.cs.num = T_1_1.num;
        }
        }

  LINE(30);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        locals.err = stringOPsize(locals.s, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        T_1_2.num = (T_1_1.num < locals.w.num)? true : false;
        if (T_1_2.num != true) { break; }

  LINE(31);
        {
        CLUREF T_2_1;
        locals.err = stringOPconcat(locals.cs, locals.s, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.s.num = T_2_1.num;
        }
        }
        end_while_1:;

  LINE(33);
    {
    {
    ret_1->num = locals.s.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 padlc ****/

extern struct OPS *char_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist6 *locals;
    Vlist1 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_padlc_actual;
static Vlist1 vals_padlc = {0, 1, { {0, 2, "", &string_ops}}
};
static siglist0 sigs_padlc = {0, 0};
static Vlist6 locals_padlc = {0, 6,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "cs", &string_ops},  {0, 2, "s", &string_ops},  {0, 2, "w", &int_ops},  {0, 2, "c", &char_ops}}
};
static Vlist0 popowns_padlc = {0, 0};
Slist0 tformals_padlc = {0, 0};
Slist0 opformals_padlc = {0, 0};
dbg_info_padlc_actual dbg_info_padlc_data = {0, 12, 
    "padlc", "/common/pub/dcurtis-temp/pclu/lib/clu/string_ops.clu", 0, 0, (int)padlc, 3, 
    &vals_padlc, &sigs_padlc, &locals_padlc, &owns_padlc, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_padlc = (struct dbg_info*)&dbg_info_padlc_data;

extern struct dbg_info* dbg_info_padrc;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG padrc_TRACE
int padrc_TRACE;
static Vlist1 owns_padrc = {0, 1,{ {0, 2, "_init", &int_ops}
}
};
extern errcode stringOPappend();
extern OWN_req int_ownreqs;
static int padrc_own_init = 0;

/**** BEGIN PROCEDURE padrc ****/

errcode padrc(s, w, c, ret_1)
CLUREF s;
CLUREF w;
CLUREF c;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF s;
        CLUREF w;
        CLUREF c;
        } locals;
    locals.s.num = UNINIT;
    locals.w.num = UNINIT;
    locals.c.num = UNINIT;
    locals.DBG_INFO = dbg_info_padrc;
    locals.s = s;
    locals.w = w;
    locals.c = c;
        if (padrc_own_init == 0) {
        padrc_own_init = 1;
    }
    enter_proc(36);

  LINE(37);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        locals.err = stringOPsize(locals.s, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        T_1_2.num = (T_1_1.num < locals.w.num)? true : false;
        if (T_1_2.num != true) { break; }

  LINE(38);
        {
        CLUREF T_2_1;
        locals.err = stringOPappend(locals.s, locals.c, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.s.num = T_2_1.num;
        }
        }
        end_while_1:;

  LINE(40);
    {
    {
    ret_1->num = locals.s.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 padrc ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist5 *locals;
    Vlist1 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_padrc_actual;
static Vlist1 vals_padrc = {0, 1, { {0, 2, "", &string_ops}}
};
static siglist0 sigs_padrc = {0, 0};
static Vlist5 locals_padrc = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "s", &string_ops},  {0, 2, "w", &int_ops},  {0, 2, "c", &char_ops}}
};
static Vlist0 popowns_padrc = {0, 0};
Slist0 tformals_padrc = {0, 0};
Slist0 opformals_padrc = {0, 0};
dbg_info_padrc_actual dbg_info_padrc_data = {0, 12, 
    "padrc", "/common/pub/dcurtis-temp/pclu/lib/clu/string_ops.clu", 0, 0, (int)padrc, 3, 
    &vals_padrc, &sigs_padrc, &locals_padrc, &owns_padrc, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_padrc = (struct dbg_info*)&dbg_info_padrc_data;

extern struct dbg_info* dbg_info_upper;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG upper_TRACE
int upper_TRACE;
static Vlist1 owns_upper = {0, 1,{ {0, 2, "_init", &int_ops}
}
};
extern errcode charOPge();
extern errcode charOPle();
extern errcode charOPi2c();
extern errcode intOPsub();
extern errcode charOPc2i();
extern OWN_req char_ownreqs;
static int upper_own_init = 0;

/**** BEGIN PROCEDURE upper ****/

errcode upper(c, ret_1)
CLUREF c;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF c;
        } locals;
    locals.c.num = UNINIT;
    locals.DBG_INFO = dbg_info_upper;
    locals.c = c;
        if (upper_own_init == 0) {
        upper_own_init = 1;
    }
    enter_proc(43);

  LINE(44);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    CLUREF T_1_5;
    T_1_2.ch = 'a';
    locals.err = charOPge(locals.c, T_1_2, &T_1_3);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_1.num = T_1_3.num;
    if (T_1_3.num) {
        T_1_4.ch = 'z';
        locals.err = charOPle(locals.c, T_1_4, &T_1_5);
        if (locals.err != ERR_ok) goto ex_0;
        T_1_1.num = T_1_5.num;
    }
    if (T_1_1.num == true) {
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = (int)(locals.c.ch & 0xff);
        locals.err = intOPsub(T_2_1, CLU_32, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = charOPi2c(T_2_2, &T_2_3);
        if (locals.err != ERR_ok) goto ex_0;
        ret_1->num = T_2_3.num;
        }
        {signal (ERR_ok);}}
        }
    else {

  LINE(45);
        {
        {
        ret_1->num = locals.c.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 upper ****/

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;
    Vlist1 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_upper_actual;
static Vlist1 vals_upper = {0, 1, { {0, 2, "", &char_ops}}
};
static siglist0 sigs_upper = {0, 0};
static Vlist3 locals_upper = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "c", &char_ops}}
};
static Vlist0 popowns_upper = {0, 0};
Slist0 tformals_upper = {0, 0};
Slist0 opformals_upper = {0, 0};
dbg_info_upper_actual dbg_info_upper_data = {0, 12, 
    "upper", "/common/pub/dcurtis-temp/pclu/lib/clu/string_ops.clu", 0, 0, (int)upper, 1, 
    &vals_upper, &sigs_upper, &locals_upper, &owns_upper, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_upper = (struct dbg_info*)&dbg_info_upper_data;

extern struct dbg_info* dbg_info_lower;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG lower_TRACE
int lower_TRACE;
static Vlist1 owns_lower = {0, 1,{ {0, 2, "_init", &int_ops}
}
};
extern errcode intOPadd();
static int lower_own_init = 0;

/**** BEGIN PROCEDURE lower ****/

errcode lower(c, ret_1)
CLUREF c;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF c;
        } locals;
    locals.c.num = UNINIT;
    locals.DBG_INFO = dbg_info_lower;
    locals.c = c;
        if (lower_own_init == 0) {
        lower_own_init = 1;
    }
    enter_proc(49);

  LINE(50);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    CLUREF T_1_5;
    T_1_2.ch = 'A';
    locals.err = charOPge(locals.c, T_1_2, &T_1_3);
    if (locals.err != ERR_ok) goto ex_0;
    T_1_1.num = T_1_3.num;
    if (T_1_3.num) {
        T_1_4.ch = 'Z';
        locals.err = charOPle(locals.c, T_1_4, &T_1_5);
        if (locals.err != ERR_ok) goto ex_0;
        T_1_1.num = T_1_5.num;
    }
    if (T_1_1.num == true) {
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        T_2_1.num = (int)(locals.c.ch & 0xff);
        locals.err = intOPadd(T_2_1, CLU_32, &T_2_2);
        if (locals.err != ERR_ok) goto ex_0;
        locals.err = charOPi2c(T_2_2, &T_2_3);
        if (locals.err != ERR_ok) goto ex_0;
        ret_1->num = T_2_3.num;
        }
        {signal (ERR_ok);}}
        }
    else {

  LINE(51);
        {
        {
        ret_1->num = locals.c.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 lower ****/

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;
    Vlist1 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_lower_actual;
static Vlist1 vals_lower = {0, 1, { {0, 2, "", &char_ops}}
};
static siglist0 sigs_lower = {0, 0};
static Vlist3 locals_lower = {0, 3,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "c", &char_ops}}
};
static Vlist0 popowns_lower = {0, 0};
Slist0 tformals_lower = {0, 0};
Slist0 opformals_lower = {0, 0};
dbg_info_lower_actual dbg_info_lower_data = {0, 12, 
    "lower", "/common/pub/dcurtis-temp/pclu/lib/clu/string_ops.clu", 0, 0, (int)lower, 1, 
    &vals_lower, &sigs_lower, &locals_lower, &owns_lower, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_lower = (struct dbg_info*)&dbg_info_lower_data;

extern struct dbg_info* dbg_info_supper;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG supper_TRACE
int supper_TRACE;
static Vlist1 owns_supper = {0, 1,{ {0, 2, "_init", &int_ops}
}
};
extern errcode supper_IB_1();
extern errcode stringOPs2ac();
extern errcode arrayOPindexes();
extern errcode arrayOPstore();
extern errcode upper();
extern errcode arrayOPfetch();
extern errcode stringOPac2s();
extern struct REQS *array_of_t_reqs;
extern OWN_req array_ownreqs;
extern struct OPS *array_ops;
struct OPS *array_of_char_table;
struct OPS *array_of_char_ops;
struct OPS *array_of_char_ops;
OWNPTR array_of_char_owns;
static int supper_own_init = 0;

/**** BEGIN PROCEDURE supper ****/

errcode supper(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_supper;
    locals.s = s;
        if (supper_own_init == 0) {
        add_parm_info_type(0, char_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(array_of_char_ops));
        supper_own_init = 1;
    }
    enter_proc(55);

  LINE(57);
    {
        {CLUREF T_1_1;
        locals.err = stringOPs2ac(locals.s, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.a.num = T_1_1.num;
        }
        }

  LINE(58);
    {
        locals.err = arrayOPindexes(locals.a, supper_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        ret_1->num = elist[0].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_0;
        }

  LINE(61);
    {
    {
    CLUREF T_1_1;
    locals.err = stringOPac2s(locals.a, &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 supper ****/

extern struct OPS *array_of_char_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist5 *locals;
    Vlist1 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_supper_actual;
static Vlist1 vals_supper = {0, 1, { {0, 2, "", &string_ops}}
};
static siglist0 sigs_supper = {0, 0};
static Vlist5 locals_supper = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &array_of_char_ops},  {0, 2, "i", &int_ops},  {0, 2, "s", &string_ops}}
};
static Vlist0 popowns_supper = {0, 0};
Slist0 tformals_supper = {0, 0};
Slist0 opformals_supper = {0, 0};
dbg_info_supper_actual dbg_info_supper_data = {0, 12, 
    "supper", "/common/pub/dcurtis-temp/pclu/lib/clu/string_ops.clu", 0, 0, (int)supper, 1, 
    &vals_supper, &sigs_supper, &locals_supper, &owns_supper, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_supper = (struct dbg_info*)&dbg_info_supper_data;

/**** BEGIN ITERATOR BODIES for supper ****/

errcode supper_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 a;
    CLUREF i;
    CLUREF s;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(59);

  FB_LINE(59);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    locals->err = arrayOPfetch(locals->a, locals->i, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->err = upper(T_1_1, &T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    locals->err = arrayOPstore(locals->a, locals->i, T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end supper_IB_1 */

/**** END ITERATOR BODIES for supper ****/


extern struct dbg_info* dbg_info_slower;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG slower_TRACE
int slower_TRACE;
static Vlist1 owns_slower = {0, 1,{ {0, 2, "_init", &int_ops}
}
};
extern errcode slower_IB_1();
extern errcode lower();
struct OPS *array_of_char_table;
struct OPS *array_of_char_ops;
struct OPS *array_of_char_ops;
OWNPTR array_of_char_owns;
static int slower_own_init = 0;

/**** BEGIN PROCEDURE slower ****/

errcode slower(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_slower;
    locals.s = s;
        if (slower_own_init == 0) {
        add_parm_info_type(0, char_ops, array_of_t_reqs);
        find_type_instance(array_ops, 1, &array_ownreqs, &(array_of_char_ops));
        slower_own_init = 1;
    }
    enter_proc(64);

  LINE(66);
    {
        {CLUREF T_1_1;
        locals.err = stringOPs2ac(locals.s, &T_1_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.a.num = T_1_1.num;
        }
        }

  LINE(67);
    {
        locals.err = arrayOPindexes(locals.a, slower_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        ret_1->num = elist[0].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_0;
        }

  LINE(70);
    {
    {
    CLUREF T_1_1;
    locals.err = stringOPac2s(locals.a, &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 slower ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist5 *locals;
    Vlist1 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_slower_actual;
static Vlist1 vals_slower = {0, 1, { {0, 2, "", &string_ops}}
};
static siglist0 sigs_slower = {0, 0};
static Vlist5 locals_slower = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "a", &array_of_char_ops},  {0, 2, "i", &int_ops},  {0, 2, "s", &string_ops}}
};
static Vlist0 popowns_slower = {0, 0};
Slist0 tformals_slower = {0, 0};
Slist0 opformals_slower = {0, 0};
dbg_info_slower_actual dbg_info_slower_data = {0, 12, 
    "slower", "/common/pub/dcurtis-temp/pclu/lib/clu/string_ops.clu", 0, 0, (int)slower, 1, 
    &vals_slower, &sigs_slower, &locals_slower, &owns_slower, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_slower = (struct dbg_info*)&dbg_info_slower_data;

/**** BEGIN ITERATOR BODIES for slower ****/

errcode slower_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 a;
    CLUREF i;
    CLUREF s;
    } *locals;
{
    locals->i.num = iv_1.num;
    enter_iter_body_proc(68);

  FB_LINE(68);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    locals->err = arrayOPfetch(locals->a, locals->i, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    locals->err = lower(T_1_1, &T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    locals->err = arrayOPstore(locals->a, locals->i, T_1_2);
    if (locals->err != ERR_ok) goto ex_0;
    }
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end slower_IB_1 */

/**** END ITERATOR BODIES for slower ****/


extern struct dbg_info* dbg_info_verify;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG verify_TRACE
int verify_TRACE;
static Vlist1 owns_verify = {0, 1,{ {0, 2, "_init", &int_ops}
}
};
extern errcode verify_IB_1();
extern errcode stringOPchars();
extern errcode intOPequal();
extern errcode stringOPindexc();
static int verify_own_init = 0;

/**** BEGIN PROCEDURE verify ****/

errcode verify(s, chars, ret_1)
CLUREF s;
CLUREF chars;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF c;
        CLUREF s;
        CLUREF chars;
        } locals;
    locals.c.num = UNINIT;
    locals.s.num = UNINIT;
    locals.chars.num = UNINIT;
    locals.DBG_INFO = dbg_info_verify;
    locals.s = s;
    locals.chars = chars;
        if (verify_own_init == 0) {
        verify_own_init = 1;
    }
    enter_proc(73);

  LINE(74);
    {
        locals.err = stringOPchars(locals.s, verify_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        ret_1->num = elist[0].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_0;
        }

  LINE(77);
    {
    {
    ret_1->tf = false;
    }
    {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 verify ****/

extern struct OPS *bool_ops;
typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist5 *locals;
    Vlist1 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_verify_actual;
static Vlist1 vals_verify = {0, 1, { {0, 2, "", &bool_ops}}
};
static siglist0 sigs_verify = {0, 0};
static Vlist5 locals_verify = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "c", &char_ops},  {0, 2, "s", &string_ops},  {0, 2, "chars", &string_ops}}
};
static Vlist0 popowns_verify = {0, 0};
Slist0 tformals_verify = {0, 0};
Slist0 opformals_verify = {0, 0};
dbg_info_verify_actual dbg_info_verify_data = {0, 12, 
    "verify", "/common/pub/dcurtis-temp/pclu/lib/clu/string_ops.clu", 0, 0, (int)verify, 2, 
    &vals_verify, &sigs_verify, &locals_verify, &owns_verify, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_verify = (struct dbg_info*)&dbg_info_verify_data;

/**** BEGIN ITERATOR BODIES for verify ****/

errcode verify_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 c;
    CLUREF s;
    CLUREF chars;
    } *locals;
{
    locals->c.num = iv_1.num;
    enter_iter_body_proc(75);

  FB_LINE(75);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    locals->err = stringOPindexc(locals->c, locals->chars, &T_1_1);
    if (locals->err != ERR_ok) goto ex_0;
    T_1_2.num = (T_1_1.num == 0)? true : false;
    if (T_1_2.num == true) {
        {
        {
        elist[0].tf = true;
        }
        *iecode = ERR_ok;
        {signal(ERR_iterbodyreturn);}
        }
        }
        }/* end if */
    {signal(ERR_ok);}
    ex_0:
        {
            *iecode = locals->err;
            {signal(ERR_iterbodyexit);}}
    end_0: {signal(ERR_ok);}
    }/* end verify_IB_1 */

/**** END ITERATOR BODIES for verify ****/


extern struct dbg_info* dbg_info_remblank;
#undef MY_TRACE_FLAG
#define MY_TRACE_FLAG remblank_TRACE
int remblank_TRACE;
static Vlist1 owns_remblank = {0, 1,{ {0, 2, "_init", &int_ops}
}
};
extern errcode intOPle();
extern errcode charOPequal();
extern errcode stringOPfetch();
extern errcode stringOPrest();
static int remblank_own_init = 0;

/**** BEGIN PROCEDURE remblank ****/

errcode remblank(s, ret_1)
CLUREF s;
CLUREF *ret_1;
    {
    struct {
        struct dbg_info *DBG_INFO;
        int DBG_LINE;
        errcode err;
        errcode ecode2;
        CLUREF i;
        CLUREF hi;
        CLUREF s;
        } locals;
    locals.i.num = UNINIT;
    locals.hi.num = UNINIT;
    locals.s.num = UNINIT;
    locals.DBG_INFO = dbg_info_remblank;
    locals.s = s;
        if (remblank_own_init == 0) {
        remblank_own_init = 1;
    }
    enter_proc(80);

  LINE(81);
    {
        {locals.i.num = 1;
        }
        }

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

  LINE(83);
    for (;;) {
        CLUREF T_1_1;
        CLUREF T_1_2;
        CLUREF T_1_3;
        CLUREF T_1_4;
        CLUREF T_1_5;
        T_1_2.num = (locals.i.num <= locals.hi.num)? true : false;
        T_1_1.num = T_1_2.num;
        if (T_1_2.num) {
            locals.err = stringOPfetch(locals.s, locals.i, &T_1_3);
            if (locals.err != ERR_ok) goto ex_0;
            T_1_4.ch = ' ';
            T_1_5.num = (T_1_3.ch == T_1_4.ch)? true : false;
            T_1_1.num = T_1_5.num;
        }
        if (T_1_1.num != true) { break; }
        {
        CLUREF T_2_1;
        locals.err = intOPadd(locals.i, CLU_1, &T_2_1);
        if (locals.err != ERR_ok) goto ex_0;
        locals.i.num = T_2_1.num;
        }
        }
        end_while_1:;

  LINE(84);
    {
    {
    CLUREF T_1_1;
    locals.err = stringOPrest(locals.s, locals.i, &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 remblank ****/

typedef struct {
    int hdr;
    int count;
    char *name;
    char *fname;
    bool is_iter;
    int is_parmd;
    int addr;
    int nargs;
    Vlist1 *vals;
    siglist0 *sigs;
    Vlist5 *locals;
    Vlist1 *owns;
    Vlist0 *ptowns;
    Vlist0 *popowns;
    Slist0 *type_formals;
    Slist0 *op_formals;
    } dbg_info_remblank_actual;
static Vlist1 vals_remblank = {0, 1, { {0, 2, "", &string_ops}}
};
static siglist0 sigs_remblank = {0, 0};
static Vlist5 locals_remblank = {0, 5,{ {0, 2, "err", &int_ops},  {0, 2, "ecode2", &int_ops},  {0, 2, "i", &int_ops},  {0, 2, "hi", &int_ops},  {0, 2, "s", &string_ops}}
};
static Vlist0 popowns_remblank = {0, 0};
Slist0 tformals_remblank = {0, 0};
Slist0 opformals_remblank = {0, 0};
dbg_info_remblank_actual dbg_info_remblank_data = {0, 12, 
    "remblank", "/common/pub/dcurtis-temp/pclu/lib/clu/string_ops.clu", 0, 0, (int)remblank, 1, 
    &vals_remblank, &sigs_remblank, &locals_remblank, &owns_remblank, &NO_VALS, &NO_VALS, &NO_PARMS, &NO_PARMS};
    struct dbg_info *dbg_info_remblank = (struct dbg_info*)&dbg_info_remblank_data;