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

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


extern errcode get_stream();
extern errcode streamOPputs();
extern errcode duOPread_specs();
extern errcode recordOPget_1();
extern errcode boolOPnot();
extern errcode oneofOPis_4();
extern errcode stringOPconcat();
extern errcode duOPget_common();
extern errcode duspec_print();
CLUREF STR_parmblock_072_040;
CLUREF STR_apply_012;
CLUREF STR_apply_072_040;
CLUREF STR__012;
CLUREF STR__072_040no_040specs_040_012;
CLUREF STR_op_012;
CLUREF STR_a_137cons_012;
CLUREF STR_ainfo_012;
CLUREF STR_tinfo_012;
CLUREF STR_any_137_012;
CLUREF STR_force_137_012;
static int pb_print_own_init = 0;

/**** BEGIN PROCEDURE pb_print ****/

errcode pb_print(p)
CLUREF p;
    {
    errcode err;
    errcode ecode2;
    CLUREF po;
    CLUREF ct;
    CLUREF specs;
    CLUREF b;
    CLUREF cop;
        if (pb_print_own_init == 0) {
        stringOPcons("parmblock: ", CLU_1, CLU_11, &STR_parmblock_072_040);
        stringOPcons("apply\n", CLU_1, CLU_6, &STR_apply_012);
        stringOPcons("apply: ", CLU_1, CLU_7, &STR_apply_072_040);
        stringOPcons("\n", CLU_1, CLU_1, &STR__012);
        stringOPcons(": no specs \n", CLU_1, CLU_12, &STR__072_040no_040specs_040_012);
        stringOPcons("op\n", CLU_1, CLU_3, &STR_op_012);
        stringOPcons("a_cons\n", CLU_1, CLU_7, &STR_a_137cons_012);
        stringOPcons("ainfo\n", CLU_1, CLU_6, &STR_ainfo_012);
        stringOPcons("tinfo\n", CLU_1, CLU_6, &STR_tinfo_012);
        stringOPcons("any_\n", CLU_1, CLU_5, &STR_any_137_012);
        stringOPcons("force_\n", CLU_1, CLU_7, &STR_force_137_012);
        pb_print_own_init = 1;
    }
    enter_proc(8);

  LINE(9);
    {
    if (false == true) {
        {
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(10);
    {
        {CLUREF T_1_1;
        err = get_stream(&T_1_1);
        if (err != ERR_ok) goto ex_0;
        po.num = T_1_1.num;
        }
        }

  LINE(11);
    {
    err = streamOPputs(po, STR_parmblock_072_040);
    if (err != ERR_ok) goto ex_0;
    }

  LINE(12);
    {
    switch (p.cell->tag) {
    case 4: 
         {CLUREF T_1_1;
        T_1_1.num = p.cell->value;
        ct.num = T_1_1.num;

  LINE(14);
            {
            err = streamOPputs(po, STR_apply_012);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(15);
            {
                {CLUREF T_2_1;
                CLUREF T_2_2;
                CLUREF T_2_3;
                T_2_1.num = ct.vec->data[0];
                err = duOPread_specs(T_2_1, &T_2_2, &T_2_3);
                if (err != ERR_ok) goto ex_0;
                specs.num = T_2_2.num;
                b.num = T_2_3.num;
                }
                }

  LINE(16);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            if (specs.cell->tag == 4) T_2_1.num = true; else T_2_1.num = false;
            T_2_2.num = T_2_1.num ^ 1;
            if (T_2_2.num == true) {

  LINE(18);
                {
                CLUREF T_3_1;
                CLUREF T_3_2;
                CLUREF T_3_3;
                CLUREF T_3_4;
                T_3_1.num = ct.vec->data[0];
                err = duOPget_common(T_3_1, &T_3_2);
                if (err != ERR_ok) goto ex_0;
                err = stringOPconcat(STR_apply_072_040, T_3_2, &T_3_3);
                if (err != ERR_ok) goto ex_0;
                err = stringOPconcat(T_3_3, STR__012, &T_3_4);
                if (err != ERR_ok) goto ex_0;
                err = streamOPputs(po, T_3_4);
                if (err != ERR_ok) goto ex_0;
                }

  LINE(19);
                {
                err = duspec_print(specs, CLU_1);
                if (err != ERR_ok) goto ex_0;
                }
                }
            else {

  LINE(21);
                {
                CLUREF T_3_1;
                CLUREF T_3_2;
                CLUREF T_3_3;
                CLUREF T_3_4;
                T_3_1.num = ct.vec->data[0];
                err = duOPget_common(T_3_1, &T_3_2);
                if (err != ERR_ok) goto ex_0;
                err = stringOPconcat(STR_apply_072_040, T_3_2, &T_3_3);
                if (err != ERR_ok) goto ex_0;
                err = stringOPconcat(T_3_3, STR__072_040no_040specs_040_012, &T_3_4);
                if (err != ERR_ok) goto ex_0;
                err = streamOPputs(po, T_3_4);
                if (err != ERR_ok) goto ex_0;
                }
                }}/* end if */
            break;
            }
    case 6: 
         {CLUREF T_1_2;
        T_1_2.num = p.cell->value;
        cop.num = T_1_2.num;

  LINE(24);
            {
            err = streamOPputs(po, STR_op_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 1: 
         {

  LINE(26);
            {
            err = streamOPputs(po, STR_a_137cons_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 2: 
         {

  LINE(28);
            {
            err = streamOPputs(po, STR_ainfo_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 8: 
         {

  LINE(30);
            {
            err = streamOPputs(po, STR_tinfo_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 3: 
         {

  LINE(32);
            {
            err = streamOPputs(po, STR_any_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 5: 
         {

  LINE(34);
            {
            err = streamOPputs(po, STR_force_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    default: {
    }
    }
    }
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE pb_print ****/


extern errcode typespecOPget_abs();
extern errcode recordOPget_2();
extern errcode idnOPget_str();
extern errcode typespec_print();
extern errcode recordOPget_3();
CLUREF STR_typespec_072_040;
CLUREF STR_cluster_137_072_040;
CLUREF STR__054_040;
CLUREF STR_none_012;
CLUREF STR_select_012;
CLUREF STR_idn_040;
CLUREF STR_type_137_012;
CLUREF STR_clutype_072_040;
CLUREF STR_cvt_137_012;
CLUREF STR_other_072_040;
CLUREF STR_du_012;
CLUREF STR_op_072_040;
CLUREF STR__012_040_040_040_040_040_040;
CLUREF STR_return_137_072_040;
CLUREF STR_xclu_072_040;
CLUREF STR__054_012;
CLUREF STR_xsel_012;
CLUREF STR_unknown_012;
static int typespec_print_own_init = 0;

/**** BEGIN PROCEDURE typespec_print ****/

errcode typespec_print(a)
CLUREF a;
    {
    errcode err;
    errcode ecode2;
    CLUREF po;
    CLUREF ct;
    CLUREF specs;
    CLUREF b;
    CLUREF ap;
    CLUREF i;
    CLUREF o;
    CLUREF rt;
    CLUREF x;
        if (typespec_print_own_init == 0) {
        stringOPcons("typespec: ", CLU_1, CLU_10, &STR_typespec_072_040);
        stringOPcons("cluster_: ", CLU_1, CLU_10, &STR_cluster_137_072_040);
        stringOPcons(", ", CLU_1, CLU_2, &STR__054_040);
        stringOPcons("none\n", CLU_1, CLU_5, &STR_none_012);
        stringOPcons("select\n", CLU_1, CLU_7, &STR_select_012);
        stringOPcons("apply\n", CLU_1, CLU_6, &STR_apply_012);
        stringOPcons("idn ", CLU_1, CLU_4, &STR_idn_040);
        stringOPcons("\n", CLU_1, CLU_1, &STR__012);
        stringOPcons("any_\n", CLU_1, CLU_5, &STR_any_137_012);
        stringOPcons("type_\n", CLU_1, CLU_6, &STR_type_137_012);
        stringOPcons("clutype: ", CLU_1, CLU_9, &STR_clutype_072_040);
        stringOPcons("cvt_\n", CLU_1, CLU_5, &STR_cvt_137_012);
        stringOPcons("other: ", CLU_1, CLU_7, &STR_other_072_040);
        stringOPcons("du\n", CLU_1, CLU_3, &STR_du_012);
        stringOPcons("op: ", CLU_1, CLU_4, &STR_op_072_040);
        stringOPcons("\n      ", CLU_1, CLU_7, &STR__012_040_040_040_040_040_040);
        stringOPcons("return_: ", CLU_1, CLU_9, &STR_return_137_072_040);
        stringOPcons("xclu: ", CLU_1, CLU_6, &STR_xclu_072_040);
        stringOPcons(",\n", CLU_1, CLU_2, &STR__054_012);
        stringOPcons("xsel\n", CLU_1, CLU_5, &STR_xsel_012);
        stringOPcons("unknown\n", CLU_1, CLU_8, &STR_unknown_012);
        typespec_print_own_init = 1;
    }
    enter_proc(39);

  LINE(40);
    {
    if (false == true) {
        {
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(41);
    {
        {CLUREF T_1_1;
        err = get_stream(&T_1_1);
        if (err != ERR_ok) goto ex_0;
        po.num = T_1_1.num;
        }
        }

  LINE(42);
    {
    err = streamOPputs(po, STR_typespec_072_040);
    if (err != ERR_ok) goto ex_0;
    }

  LINE(43);
    {
    CLUREF T_1_1;
    err = typespecOPget_abs(a, &T_1_1);
    if (err != ERR_ok) goto ex_0;
    switch (T_1_1.cell->tag) {
    case 3: 
         {CLUREF T_1_2;
        T_1_2.num = T_1_1.cell->value;
        ct.num = T_1_2.num;

  LINE(45);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
            T_2_1.num = ct.vec->data[0];
            err = duOPget_common(T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(STR_cluster_137_072_040, T_2_2, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_3, STR__054_040, &T_2_4);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_4);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(46);
            {
                {CLUREF T_2_1;
                CLUREF T_2_2;
                CLUREF T_2_3;
                T_2_1.num = ct.vec->data[0];
                err = duOPread_specs(T_2_1, &T_2_2, &T_2_3);
                if (err != ERR_ok) goto ex_0;
                specs.num = T_2_2.num;
                b.num = T_2_3.num;
                }
                }

  LINE(47);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            if (specs.cell->tag == 4) T_2_1.num = true; else T_2_1.num = false;
            T_2_2.num = T_2_1.num ^ 1;
            if (T_2_2.num == true) {

  LINE(48);
                {
                err = duspec_print(specs, CLU_1);
                if (err != ERR_ok) goto ex_0;
                }
                }
            else {

  LINE(50);
                {
                err = streamOPputs(po, STR_none_012);
                if (err != ERR_ok) goto ex_0;
                }
                }}/* end if */
            break;
            }
    case 7: 
         {

  LINE(53);
            {
            err = streamOPputs(po, STR_select_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 2: 
         {CLUREF T_1_3;
        T_1_3.num = T_1_1.cell->value;
        ap.num = T_1_3.num;

  LINE(55);
            {
            err = streamOPputs(po, STR_apply_012);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(56);
            {
                {CLUREF T_2_1;
                CLUREF T_2_2;
                CLUREF T_2_3;
                T_2_1.num = ap.vec->data[1];
                err = duOPread_specs(T_2_1, &T_2_2, &T_2_3);
                if (err != ERR_ok) goto ex_0;
                specs.num = T_2_2.num;
                b.num = T_2_3.num;
                }
                }

  LINE(57);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            if (specs.cell->tag == 4) T_2_1.num = true; else T_2_1.num = false;
            T_2_2.num = T_2_1.num ^ 1;
            if (T_2_2.num == true) {

  LINE(58);
                {
                err = duspec_print(specs, CLU_1);
                if (err != ERR_ok) goto ex_0;
                }
                }
            else {

  LINE(60);
                {
                err = streamOPputs(po, STR_none_012);
                if (err != ERR_ok) goto ex_0;
                }
                }}/* end if */
            break;
            }
    case 5: 
         {CLUREF T_1_4;
        T_1_4.num = T_1_1.cell->value;
        i.num = T_1_4.num;

  LINE(64);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = idnOPget_str(i, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(STR_idn_040, T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_2, STR__012, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_3);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 1: 
         {

  LINE(66);
            {
            err = streamOPputs(po, STR_any_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 8: 
         {CLUREF T_1_5;
        T_1_5.num = T_1_1.cell->value;
        ct.num = T_1_5.num;

  LINE(68);
            {
            err = streamOPputs(po, STR_type_137_012);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(69);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
            T_2_1.num = ct.vec->data[0];
            err = duOPget_common(T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(STR_clutype_072_040, T_2_2, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_3, STR__054_040, &T_2_4);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_4);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(70);
            {
                {CLUREF T_2_1;
                CLUREF T_2_2;
                CLUREF T_2_3;
                T_2_1.num = ct.vec->data[0];
                err = duOPread_specs(T_2_1, &T_2_2, &T_2_3);
                if (err != ERR_ok) goto ex_0;
                specs.num = T_2_2.num;
                b.num = T_2_3.num;
                }
                }

  LINE(71);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            if (specs.cell->tag == 4) T_2_1.num = true; else T_2_1.num = false;
            T_2_2.num = T_2_1.num ^ 1;
            if (T_2_2.num == true) {

  LINE(72);
                {
                err = duspec_print(specs, CLU_1);
                if (err != ERR_ok) goto ex_0;
                }
                }
            else {

  LINE(74);
                {
                err = streamOPputs(po, STR_none_012);
                if (err != ERR_ok) goto ex_0;
                }
                }}/* end if */
            break;
            }
    case 4: 
         {

  LINE(77);
            {
            err = streamOPputs(po, STR_cvt_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 6: 
         {CLUREF T_1_6;
        T_1_6.num = T_1_1.cell->value;
        o.num = T_1_6.num;

  LINE(79);
            {
            err = streamOPputs(po, STR_other_072_040);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(80);
            {
            switch (o.cell->tag) {
            case 1: 
                 {CLUREF T_2_1;
                T_2_1.num = o.cell->value;
                ct.num = T_2_1.num;

  LINE(82);
                    {
                    err = streamOPputs(po, STR_du_012);
                    if (err != ERR_ok) goto ex_0;
                    }

  LINE(83);
                    {
                    CLUREF T_3_1;
                    CLUREF T_3_2;
                    CLUREF T_3_3;
                    CLUREF T_3_4;
                    T_3_1.num = ct.vec->data[0];
                    err = duOPget_common(T_3_1, &T_3_2);
                    if (err != ERR_ok) goto ex_0;
                    err = stringOPconcat(STR_clutype_072_040, T_3_2, &T_3_3);
                    if (err != ERR_ok) goto ex_0;
                    err = stringOPconcat(T_3_3, STR__054_040, &T_3_4);
                    if (err != ERR_ok) goto ex_0;
                    err = streamOPputs(po, T_3_4);
                    if (err != ERR_ok) goto ex_0;
                    }

  LINE(84);
                    {
                        {CLUREF T_3_1;
                        CLUREF T_3_2;
                        CLUREF T_3_3;
                        T_3_1.num = ct.vec->data[0];
                        err = duOPread_specs(T_3_1, &T_3_2, &T_3_3);
                        if (err != ERR_ok) goto ex_0;
                        specs.num = T_3_2.num;
                        b.num = T_3_3.num;
                        }
                        }

  LINE(85);
                    {
                    CLUREF T_3_1;
                    CLUREF T_3_2;
                    if (specs.cell->tag == 4) T_3_1.num = true; else T_3_1.num = false;
                    T_3_2.num = T_3_1.num ^ 1;
                    if (T_3_2.num == true) {

  LINE(86);
                        {
                        err = duspec_print(specs, CLU_1);
                        if (err != ERR_ok) goto ex_0;
                        }
                        }
                    else {

  LINE(88);
                        {
                        err = streamOPputs(po, STR_none_012);
                        if (err != ERR_ok) goto ex_0;
                        }
                        }}/* end if */
                    break;
                    }
            case 2: 
                 {CLUREF T_2_2;
                T_2_2.num = o.cell->value;
                ct.num = T_2_2.num;

  LINE(91);
                    {
                    CLUREF T_3_1;
                    CLUREF T_3_2;
                    CLUREF T_3_3;
                    T_3_1.num = ct.vec->data[0];
                    err = stringOPconcat(STR_op_072_040, T_3_1, &T_3_2);
                    if (err != ERR_ok) goto ex_0;
                    err = stringOPconcat(T_3_2, STR__012_040_040_040_040_040_040, &T_3_3);
                    if (err != ERR_ok) goto ex_0;
                    err = streamOPputs(po, T_3_3);
                    if (err != ERR_ok) goto ex_0;
                    }

  LINE(92);
                    {
                    CLUREF T_3_1;
                    T_3_1.num = ct.vec->data[2];
                    err = typespec_print(T_3_1);
                    if (err != ERR_ok) goto ex_0;
                    }
                    break;
                    }
            case 3: 
                 {CLUREF T_2_3;
                T_2_3.num = o.cell->value;
                rt.num = T_2_3.num;

  LINE(94);
                    {
                    err = streamOPputs(po, STR_return_137_072_040);
                    if (err != ERR_ok) goto ex_0;
                    }

  LINE(95);
                    {
                    err = typespec_print(rt);
                    if (err != ERR_ok) goto ex_0;
                    }
                    break;
                    }
            }
            }
            break;
            }
    case 10: 
         {CLUREF T_1_7;
        T_1_7.num = T_1_1.cell->value;
        x.num = T_1_7.num;

  LINE(98);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
            T_2_1.num = x.vec->data[0];
            err = idnOPget_str(T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(STR_xclu_072_040, T_2_2, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_3, STR__054_012, &T_2_4);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_4);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 11: 
         {

  LINE(100);
            {
            err = streamOPputs(po, STR_xsel_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 9: 
         {

  LINE(102);
            {
            err = streamOPputs(po, STR_unknown_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    }
    }
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE typespec_print ****/


extern errcode intOPunparse();
extern errcode sequenceOPsize();
CLUREF STR_restrictkind_072_012;
CLUREF STR_idn_072_040;
CLUREF STR__040_012;
CLUREF STR_set_072_040;
CLUREF STR_operdecllist_072_040;
static int restrictkind_print_own_init = 0;

/**** BEGIN PROCEDURE restrictkind_print ****/

errcode restrictkind_print(r)
CLUREF r;
    {
    errcode err;
    errcode ecode2;
    CLUREF po;
    CLUREF i;
    CLUREF x;
    CLUREF o;
        if (restrictkind_print_own_init == 0) {
        stringOPcons("restrictkind:\n", CLU_1, CLU_14, &STR_restrictkind_072_012);
        stringOPcons("idn: ", CLU_1, CLU_5, &STR_idn_072_040);
        stringOPcons(" \n", CLU_1, CLU_2, &STR__040_012);
        stringOPcons("set: ", CLU_1, CLU_5, &STR_set_072_040);
        stringOPcons("operdecllist: ", CLU_1, CLU_14, &STR_operdecllist_072_040);
        restrictkind_print_own_init = 1;
    }
    enter_proc(106);

  LINE(107);
    {
    if (false == true) {
        {
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(108);
    {
        {CLUREF T_1_1;
        err = get_stream(&T_1_1);
        if (err != ERR_ok) goto ex_0;
        po.num = T_1_1.num;
        }
        }

  LINE(109);
    {
    err = streamOPputs(po, STR_restrictkind_072_012);
    if (err != ERR_ok) goto ex_0;
    }

  LINE(110);
    {
    switch (r.cell->tag) {
    case 2: 
         {CLUREF T_1_1;
        T_1_1.num = r.cell->value;
        i.num = T_1_1.num;

  LINE(112);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = idnOPget_str(i, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(STR_idn_072_040, T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_2, STR__040_012, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_3);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 3: 
         {CLUREF T_1_2;
        T_1_2.num = r.cell->value;
        x.num = T_1_2.num;

  LINE(114);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
            T_2_1.num = x.vec->data[1];
            err = idnOPget_str(T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(STR_set_072_040, T_2_2, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_3, STR__040_012, &T_2_4);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_4);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 1: 
         {CLUREF T_1_3;
        T_1_3.num = r.cell->value;
        o.num = T_1_3.num;

  LINE(116);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
            T_2_1.num = o.vec->size;
            err = intOPunparse(T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(STR_operdecllist_072_040, T_2_2, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_3, STR__040_012, &T_2_4);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_4);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    }
    }
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE restrictkind_print ****/


extern errcode oneofOPis_2();
extern errcode idnOPsimilar();
extern errcode oneofOPvalue_2();
extern errcode oneofOPis_3();
extern errcode oneofOPvalue_3();
extern errcode sequenceOPsimilar();
extern errcode operdecllist_similar();
extern errcode oneofOPis_1();
extern errcode oneofOPvalue_1();
extern struct REQS *sequence_of_t_reqs;
extern struct OPS *equate_ops;
extern OWN_req sequence_ownreqs;
extern struct OPS *sequence_ops;
struct OPS *sequence_of_equate_table;
struct OPS *sequence_of_equate_ops;
struct OPS *sequence_of_equate_ops;
OWNPTR sequence_of_equate_owns;
static int restrictkind_similar_own_init = 0;

/**** BEGIN PROCEDURE restrictkind_similar ****/

errcode restrictkind_similar(r1, r2, ret_1)
CLUREF r1;
CLUREF r2;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF i;
    CLUREF x1;
    CLUREF x2;
    CLUREF o;
        if (restrictkind_similar_own_init == 0) {
        add_parm_info_type(0, equate_ops, sequence_of_t_reqs);
        find_type_instance(sequence_ops, 1, &sequence_ownreqs, &(sequence_of_equate_ops));
        restrictkind_similar_own_init = 1;
    }
    enter_proc(121);

  LINE(123);
    {
    switch (r1.cell->tag) {
    case 2: 
         {CLUREF T_1_1;
        T_1_1.num = r1.cell->value;
        i.num = T_1_1.num;

  LINE(125);
            {
            CLUREF T_2_1;
            if (r2.cell->tag == 2) T_2_1.num = true; else T_2_1.num = false;
            if (T_2_1.num == true) {

  LINE(127);
                {
                {
                CLUREF T_3_1;
                CLUREF T_3_2;
                if (r2.cell->tag != 2) {err = ERR_wrong_tag; goto ex_0;}
                T_3_1.num = r2.cell->value;
                err = idnOPsimilar(i, T_3_1, &T_3_2);
                if (err != ERR_ok) goto ex_0;
                ret_1->num = T_3_2.num;
                }
                {signal (ERR_ok);}}
                }
            else {

  LINE(129);
                {
                {
                ret_1->tf = false;
                }
                {signal (ERR_ok);}}
                }}/* end if */
            break;
            }
    case 3: 
         {CLUREF T_1_2;
        T_1_2.num = r1.cell->value;
        x1.num = T_1_2.num;

  LINE(132);
            {
            CLUREF T_2_1;
            if (r2.cell->tag == 3) T_2_1.num = true; else T_2_1.num = false;
            if (T_2_1.num == true) {

  LINE(134);
                {
                    {CLUREF T_3_1;
                    if (r2.cell->tag != 3) {err = ERR_wrong_tag; goto ex_0;}
                    T_3_1.num = r2.cell->value;
                    x2.num = T_3_1.num;
                    }
                    }

  LINE(135);
                {
                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_3.num = x1.vec->data[1];
                T_3_4.num = x2.vec->data[1];
                err = idnOPsimilar(T_3_3, T_3_4, &T_3_5);
                if (err != ERR_ok) goto ex_0;
                T_3_2.num = T_3_5.num;
                if (T_3_5.num) {
                    T_3_6.num = x1.vec->data[0];
                    T_3_7.num = x2.vec->data[0];
                    generic_CLU_proc.type_owns = sequence_of_equate_ops->type_owns;
                    generic_CLU_proc.proc = sequenceOPsimilar;
                    CUR_PROC_VAR.proc = &generic_CLU_proc;
                    err = sequenceOPsimilar(T_3_6, T_3_7, &T_3_8);
                    if (err != ERR_ok) goto ex_0;
                    T_3_2.num = T_3_8.num;
                }
                T_3_1.num = T_3_2.num;
                if (T_3_2.num) {
                    T_3_9.num = x1.vec->data[2];
                    T_3_10.num = x2.vec->data[2];
                    err = operdecllist_similar(T_3_9, T_3_10, &T_3_11);
                    if (err != ERR_ok) goto ex_0;
                    T_3_1.num = T_3_11.num;
                }
                if (T_3_1.num == true) {

  LINE(138);
                    {
                    {
                    ret_1->tf = true;
                    }
                    {signal (ERR_ok);}}
                    }
                else {

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

  LINE(142);
                {
                {
                ret_1->tf = false;
                }
                {signal (ERR_ok);}}
                }}/* end if */
            break;
            }
    case 1: 
         {CLUREF T_1_3;
        T_1_3.num = r1.cell->value;
        o.num = T_1_3.num;

  LINE(145);
            {
            CLUREF T_2_1;
            if (r2.cell->tag == 1) T_2_1.num = true; else T_2_1.num = false;
            if (T_2_1.num == true) {

  LINE(147);
                {
                {
                CLUREF T_3_1;
                CLUREF T_3_2;
                if (r2.cell->tag != 1) {err = ERR_wrong_tag; goto ex_0;}
                T_3_1.num = r2.cell->value;
                err = operdecllist_similar(o, T_3_1, &T_3_2);
                if (err != ERR_ok) goto ex_0;
                ret_1->num = T_3_2.num;
                }
                {signal (ERR_ok);}}
                }
            else {

  LINE(149);
                {
                {
                ret_1->tf = false;
                }
                {signal (ERR_ok);}}
                }}/* end if */
            break;
            }
    }
    }
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE restrictkind_similar ****/


extern errcode intOPequal();
extern errcode sequenceOPindexes();
extern errcode sequenceOPfetch();
extern errcode stringOPequal();
extern errcode typespec_similar();
extern struct OPS *expr_ops;
struct OPS *sequence_of_expr_table;
struct OPS *sequence_of_expr_ops;
struct OPS *sequence_of_expr_ops;
OWNPTR sequence_of_expr_owns;
static int operdecllist_similar_own_init = 0;

/**** BEGIN PROCEDURE operdecllist_similar ****/

errcode operdecllist_similar(o1, o2, ret_1)
CLUREF o1;
CLUREF o2;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF i;
    CLUREF j;
        if (operdecllist_similar_own_init == 0) {
        add_parm_info_type(0, expr_ops, sequence_of_t_reqs);
        find_type_instance(sequence_ops, 1, &sequence_ownreqs, &(sequence_of_expr_ops));
        operdecllist_similar_own_init = 1;
    }
    enter_proc(156);

  LINE(157);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = o1.vec->size;
    T_1_2.num = o2.vec->size;
    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(158);
        {
        {
        ret_1->tf = false;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(160);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
        T_1_2.num = o1.vec->size; 
        for (T_1_1.num = 1; T_1_1.num <= T_1_2.num; T_1_1.num++) {
            i.num = T_1_1.num;

  LINE(161);
            {
            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;
            if (i.num < 1 || i.num > o1.vec->size ) {
                err = ERR_bounds;
                goto ex_0;}
            T_2_1.num = o1.vec->data[i.num - 1];
            T_2_2.num = T_2_1.vec->data[1];
            T_2_3.num = T_2_2.vec->size;
            if (i.num < 1 || i.num > o2.vec->size ) {
                err = ERR_bounds;
                goto ex_0;}
            T_2_4.num = o2.vec->data[i.num - 1];
            T_2_5.num = T_2_4.vec->data[1];
            T_2_6.num = T_2_5.vec->size;
            T_2_7.num = (T_2_3.num == T_2_6.num)? true : false;
            T_2_8.num = T_2_7.num ^ 1;
            if (T_2_8.num == true) {

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

  LINE(164);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
                if (i.num < 1 || i.num > o1.vec->size ) {
                    err = ERR_bounds;
                    goto ex_0;}
                T_2_1.num = o1.vec->data[i.num - 1];
                T_2_2.num = T_2_1.vec->data[1];
                T_2_4.num = T_2_2.vec->size; 
                for (T_2_3.num = 1; T_2_3.num <= T_2_4.num; T_2_3.num++) {
                    j.num = T_2_3.num;

  LINE(165);
                    {
                    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;
                    if (i.num < 1 || i.num > o1.vec->size ) {
                        err = ERR_bounds;
                        goto ex_0;}
                    T_3_1.num = o1.vec->data[i.num - 1];
                    T_3_2.num = T_3_1.vec->data[1];
                    if (j.num < 1 || j.num > T_3_2.vec->size ) {
                        err = ERR_bounds;
                        goto ex_0;}
                    T_3_3.num = T_3_2.vec->data[j.num - 1];
                    T_3_4.num = T_3_3.vec->data[0];
                    if (i.num < 1 || i.num > o2.vec->size ) {
                        err = ERR_bounds;
                        goto ex_0;}
                    T_3_5.num = o2.vec->data[i.num - 1];
                    T_3_6.num = T_3_5.vec->data[1];
                    if (j.num < 1 || j.num > T_3_6.vec->size ) {
                        err = ERR_bounds;
                        goto ex_0;}
                    T_3_7.num = T_3_6.vec->data[j.num - 1];
                    T_3_8.num = T_3_7.vec->data[0];
                    T_3_9.num = ((T_3_4.str->size != T_3_8.str->size)? false :
                        !(bcmp(T_3_4.str->data, T_3_8.str->data, T_3_4.str->size)));
                    T_3_10.num = T_3_9.num ^ 1;
                    if (T_3_10.num == true) {

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

  LINE(168);
                    {
                    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;
                    if (i.num < 1 || i.num > o1.vec->size ) {
                        err = ERR_bounds;
                        goto ex_0;}
                    T_3_1.num = o1.vec->data[i.num - 1];
                    T_3_2.num = T_3_1.vec->data[1];
                    if (j.num < 1 || j.num > T_3_2.vec->size ) {
                        err = ERR_bounds;
                        goto ex_0;}
                    T_3_3.num = T_3_2.vec->data[j.num - 1];
                    T_3_4.num = T_3_3.vec->data[1];
                    if (i.num < 1 || i.num > o2.vec->size ) {
                        err = ERR_bounds;
                        goto ex_0;}
                    T_3_5.num = o2.vec->data[i.num - 1];
                    T_3_6.num = T_3_5.vec->data[1];
                    if (j.num < 1 || j.num > T_3_6.vec->size ) {
                        err = ERR_bounds;
                        goto ex_0;}
                    T_3_7.num = T_3_6.vec->data[j.num - 1];
                    T_3_8.num = T_3_7.vec->data[1];
                    generic_CLU_proc.type_owns = sequence_of_expr_ops->type_owns;
                    generic_CLU_proc.proc = sequenceOPsimilar;
                    CUR_PROC_VAR.proc = &generic_CLU_proc;
                    err = sequenceOPsimilar(T_3_4, T_3_8, &T_3_9);
                    if (err != ERR_ok) goto ex_0;
                    T_3_10.num = T_3_9.num ^ 1;
                    if (T_3_10.num == true) {

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

  LINE(171);
                    {
                    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;
                    if (i.num < 1 || i.num > o1.vec->size ) {
                        err = ERR_bounds;
                        goto ex_0;}
                    T_3_1.num = o1.vec->data[i.num - 1];
                    T_3_2.num = T_3_1.vec->data[1];
                    if (j.num < 1 || j.num > T_3_2.vec->size ) {
                        err = ERR_bounds;
                        goto ex_0;}
                    T_3_3.num = T_3_2.vec->data[j.num - 1];
                    T_3_4.num = T_3_3.vec->data[2];
                    if (i.num < 1 || i.num > o2.vec->size ) {
                        err = ERR_bounds;
                        goto ex_0;}
                    T_3_5.num = o2.vec->data[i.num - 1];
                    T_3_6.num = T_3_5.vec->data[1];
                    if (j.num < 1 || j.num > T_3_6.vec->size ) {
                        err = ERR_bounds;
                        goto ex_0;}
                    T_3_7.num = T_3_6.vec->data[j.num - 1];
                    T_3_8.num = T_3_7.vec->data[2];
                    err = typespec_similar(T_3_4, T_3_8, &T_3_9);
                    if (err != ERR_ok) goto ex_0;
                    T_3_10.num = T_3_9.num ^ 1;
                    if (T_3_10.num == true) {

  LINE(172);
                        {
                        {
                        ret_1->tf = false;
                        }
                        {signal (ERR_ok);}}
                        }
                        }/* end if */
                }
            }
            end_inline_for_2:;
        }
    }
    end_inline_for_1:;

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

/**** END PROCEDURE operdecllist_similar ****/


extern errcode oneofOPis_8();
extern errcode oneofOPvalue_8();
extern errcode oneofOPis_7();
extern errcode oneofOPvalue_7();
extern errcode typelist_similar();
extern errcode recordOPget_4();
extern errcode exceptionlist_similar();
extern errcode oneofOPis_6();
extern errcode oneofOPis_10();
extern errcode oneofOPis_11();
extern errcode oneofOPis_5();
extern errcode oneofOPvalue_5();
extern errcode oneofOPis_9();
struct OPS *sequence_of_expr_table;
struct OPS *sequence_of_expr_ops;
struct OPS *sequence_of_expr_ops;
OWNPTR sequence_of_expr_owns;
extern struct OPS *string_ops;
extern struct OPS *typespec_ops;
struct OPS  *record_sel_type__ops;
extern struct OPS *record_sel_type__ops;
struct OPS *sequence_of_record_sel_type__table;
struct OPS *sequence_of_record_sel_type__ops;
struct OPS *sequence_of_record_sel_type__ops;
OWNPTR sequence_of_record_sel_type__owns;
static int typespec_similar_own_init = 0;

/**** BEGIN PROCEDURE typespec_similar ****/

errcode typespec_similar(t1, t2, ret_1)
CLUREF t1;
CLUREF t2;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF c1;
    CLUREF c2;
    CLUREF s1;
    CLUREF s2;
    CLUREF a1;
    CLUREF a2;
    CLUREF i;
        if (typespec_similar_own_init == 0) {
        add_parm_info_type(0, expr_ops, sequence_of_t_reqs);
        find_type_instance(sequence_ops, 1, &sequence_ownreqs, &(sequence_of_expr_ops));
        add_selector_info("sel", 0, string_ops); 
        add_selector_info("type_", 1, typespec_ops); 
        find_selector_ops("record", 2, &(record_sel_type__ops));
        add_parm_info_type(0, record_sel_type__ops, sequence_of_t_reqs);
        find_type_instance(sequence_ops, 1, &sequence_ownreqs, &(sequence_of_record_sel_type__ops));
        typespec_similar_own_init = 1;
    }
    enter_proc(179);

  LINE(180);
    {
    CLUREF T_1_1;
    err = typespecOPget_abs(t1, &T_1_1);
    if (err != ERR_ok) goto ex_0;
    switch (T_1_1.cell->tag) {
    case 3: 
         {CLUREF T_1_2;
        T_1_2.num = T_1_1.cell->value;
        c1.num = T_1_2.num;

  LINE(183);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = typespecOPget_abs(t2, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            if (T_2_1.cell->tag == 3) T_2_2.num = true; else T_2_2.num = false;
            T_2_3.num = T_2_2.num ^ 1;
            if (T_2_3.num == true) {

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

  LINE(185);
            {
                {CLUREF T_2_1;
                CLUREF T_2_2;
                err = typespecOPget_abs(t2, &T_2_1);
                if (err != ERR_ok) goto ex_0;
                if (T_2_1.cell->tag != 3) {err = ERR_wrong_tag; goto ex_0;}
                T_2_2.num = T_2_1.cell->value;
                c2.num = T_2_2.num;
                }
                }

  LINE(186);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
            T_2_1.num = c1.vec->data[1];
            T_2_2.num = c2.vec->data[1];
            generic_CLU_proc.type_owns = sequence_of_expr_ops->type_owns;
            generic_CLU_proc.proc = sequenceOPsimilar;
            CUR_PROC_VAR.proc = &generic_CLU_proc;
            err = sequenceOPsimilar(T_2_1, T_2_2, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            T_2_4.num = T_2_3.num ^ 1;
            if (T_2_4.num == true) {

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

  LINE(188);
            {
            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 = c1.vec->data[0];
            err = duOPget_common(T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            T_2_3.num = c2.vec->data[0];
            err = duOPget_common(T_2_3, &T_2_4);
            if (err != ERR_ok) goto ex_0;
            T_2_5.num = ((T_2_2.str->size != T_2_4.str->size)? false :
                !(bcmp(T_2_2.str->data, T_2_4.str->data, T_2_2.str->size)));
            T_2_6.num = T_2_5.num ^ 1;
            if (T_2_6.num == true) {

  LINE(189);
                {
                {
                ret_1->tf = false;
                }
                {signal (ERR_ok);}}
                }
            else {

  LINE(190);
                {
                {
                ret_1->tf = true;
                }
                {signal (ERR_ok);}}
                }}/* end if */
            break;
            }
    case 8: 
         {CLUREF T_1_3;
        T_1_3.num = T_1_1.cell->value;
        c1.num = T_1_3.num;

  LINE(193);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = typespecOPget_abs(t2, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            if (T_2_1.cell->tag == 8) T_2_2.num = true; else T_2_2.num = false;
            T_2_3.num = T_2_2.num ^ 1;
            if (T_2_3.num == true) {

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

  LINE(195);
            {
                {CLUREF T_2_1;
                CLUREF T_2_2;
                err = typespecOPget_abs(t2, &T_2_1);
                if (err != ERR_ok) goto ex_0;
                if (T_2_1.cell->tag != 8) {err = ERR_wrong_tag; goto ex_0;}
                T_2_2.num = T_2_1.cell->value;
                c2.num = T_2_2.num;
                }
                }

  LINE(196);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
            T_2_1.num = c1.vec->data[1];
            T_2_2.num = c2.vec->data[1];
            generic_CLU_proc.type_owns = sequence_of_expr_ops->type_owns;
            generic_CLU_proc.proc = sequenceOPsimilar;
            CUR_PROC_VAR.proc = &generic_CLU_proc;
            err = sequenceOPsimilar(T_2_1, T_2_2, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            T_2_4.num = T_2_3.num ^ 1;
            if (T_2_4.num == true) {

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

  LINE(198);
            {
            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 = c1.vec->data[0];
            err = duOPget_common(T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            T_2_3.num = c2.vec->data[0];
            err = duOPget_common(T_2_3, &T_2_4);
            if (err != ERR_ok) goto ex_0;
            T_2_5.num = ((T_2_2.str->size != T_2_4.str->size)? false :
                !(bcmp(T_2_2.str->data, T_2_4.str->data, T_2_2.str->size)));
            T_2_6.num = T_2_5.num ^ 1;
            if (T_2_6.num == true) {

  LINE(199);
                {
                {
                ret_1->tf = false;
                }
                {signal (ERR_ok);}}
                }
            else {

  LINE(200);
                {
                {
                ret_1->tf = true;
                }
                {signal (ERR_ok);}}
                }}/* end if */
            break;
            }
    case 7: 
         {CLUREF T_1_4;
        T_1_4.num = T_1_1.cell->value;
        s1.num = T_1_4.num;

  LINE(202);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = typespecOPget_abs(t2, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            if (T_2_1.cell->tag == 7) T_2_2.num = true; else T_2_2.num = false;
            T_2_3.num = T_2_2.num ^ 1;
            if (T_2_3.num == true) {

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

  LINE(204);
            {
                {CLUREF T_2_1;
                CLUREF T_2_2;
                err = typespecOPget_abs(t2, &T_2_1);
                if (err != ERR_ok) goto ex_0;
                if (T_2_1.cell->tag != 7) {err = ERR_wrong_tag; goto ex_0;}
                T_2_2.num = T_2_1.cell->value;
                s2.num = T_2_2.num;
                }
                }

  LINE(205);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
            T_2_1.num = s1.vec->data[1];
            T_2_2.num = s2.vec->data[1];
            generic_CLU_proc.type_owns = sequence_of_record_sel_type__ops->type_owns;
            generic_CLU_proc.proc = sequenceOPsimilar;
            CUR_PROC_VAR.proc = &generic_CLU_proc;
            err = sequenceOPsimilar(T_2_1, T_2_2, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            T_2_4.num = T_2_3.num ^ 1;
            if (T_2_4.num == true) {

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

  LINE(207);
            {
            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 = s1.vec->data[0];
            err = duOPget_common(T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            T_2_3.num = s2.vec->data[0];
            err = duOPget_common(T_2_3, &T_2_4);
            if (err != ERR_ok) goto ex_0;
            T_2_5.num = ((T_2_2.str->size != T_2_4.str->size)? false :
                !(bcmp(T_2_2.str->data, T_2_4.str->data, T_2_2.str->size)));
            T_2_6.num = T_2_5.num ^ 1;
            if (T_2_6.num == true) {

  LINE(208);
                {
                {
                ret_1->tf = false;
                }
                {signal (ERR_ok);}}
                }
            else {

  LINE(209);
                {
                {
                ret_1->tf = true;
                }
                {signal (ERR_ok);}}
                }}/* end if */
            break;
            }
    case 2: 
         {CLUREF T_1_5;
        T_1_5.num = T_1_1.cell->value;
        a1.num = T_1_5.num;

  LINE(212);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = typespecOPget_abs(t2, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            if (T_2_1.cell->tag == 2) T_2_2.num = true; else T_2_2.num = false;
            T_2_3.num = T_2_2.num ^ 1;
            if (T_2_3.num == true) {

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

  LINE(214);
            {
                {CLUREF T_2_1;
                CLUREF T_2_2;
                err = typespecOPget_abs(t2, &T_2_1);
                if (err != ERR_ok) goto ex_0;
                if (T_2_1.cell->tag != 2) {err = ERR_wrong_tag; goto ex_0;}
                T_2_2.num = T_2_1.cell->value;
                a2.num = T_2_2.num;
                }
                }

  LINE(215);
            {
            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 = a1.vec->data[1];
            err = duOPget_common(T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            T_2_3.num = a2.vec->data[1];
            err = duOPget_common(T_2_3, &T_2_4);
            if (err != ERR_ok) goto ex_0;
            T_2_5.num = ((T_2_2.str->size != T_2_4.str->size)? false :
                !(bcmp(T_2_2.str->data, T_2_4.str->data, T_2_2.str->size)));
            T_2_6.num = T_2_5.num ^ 1;
            if (T_2_6.num == true) {

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

  LINE(217);
            {
            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;
            T_2_3.num = a1.vec->data[0];
            T_2_4.num = a2.vec->data[0];
            err = typelist_similar(T_2_3, T_2_4, &T_2_5);
            if (err != ERR_ok) goto ex_0;
            T_2_6.num = T_2_5.num ^ 1;
            T_2_2.num = T_2_6.num;
            if (!T_2_6.num) {
                T_2_7.num = a1.vec->data[3];
                T_2_8.num = a2.vec->data[3];
                err = typelist_similar(T_2_7, T_2_8, &T_2_9);
                if (err != ERR_ok) goto ex_0;
                T_2_10.num = T_2_9.num ^ 1;
                T_2_2.num = T_2_10.num;
            }
            T_2_1.num = T_2_2.num;
            if (!T_2_2.num) {
                T_2_11.num = a1.vec->data[2];
                T_2_12.num = a2.vec->data[2];
                err = exceptionlist_similar(T_2_11, T_2_12, &T_2_13);
                if (err != ERR_ok) goto ex_0;
                T_2_14.num = T_2_13.num ^ 1;
                T_2_1.num = T_2_14.num;
            }
            if (T_2_1.num == true) {

  LINE(220);
                {
                {
                ret_1->tf = false;
                }
                {signal (ERR_ok);}}
                }
            else {

  LINE(221);
                {
                {
                ret_1->tf = true;
                }
                {signal (ERR_ok);}}
                }}/* end if */
            break;
            }
    case 6: 
         {

  LINE(224);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = typespecOPget_abs(t2, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            if (T_2_1.cell->tag == 6) T_2_2.num = true; else T_2_2.num = false;
            T_2_3.num = T_2_2.num ^ 1;
            if (T_2_3.num == true) {

  LINE(225);
                {
                {
                ret_1->tf = false;
                }
                {signal (ERR_ok);}}
                }
                }/* end if */
            break;
            }
    case 10: 
         {

  LINE(228);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = typespecOPget_abs(t2, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            if (T_2_1.cell->tag == 10) T_2_2.num = true; else T_2_2.num = false;
            T_2_3.num = T_2_2.num ^ 1;
            if (T_2_3.num == true) {

  LINE(229);
                {
                {
                ret_1->tf = false;
                }
                {signal (ERR_ok);}}
                }
                }/* end if */
            break;
            }
    case 11: 
         {

  LINE(232);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = typespecOPget_abs(t2, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            if (T_2_1.cell->tag == 11) T_2_2.num = true; else T_2_2.num = false;
            T_2_3.num = T_2_2.num ^ 1;
            if (T_2_3.num == true) {

  LINE(233);
                {
                {
                ret_1->tf = false;
                }
                {signal (ERR_ok);}}
                }
                }/* end if */
            break;
            }
    case 5: 
         {CLUREF T_1_6;
        T_1_6.num = T_1_1.cell->value;
        i.num = T_1_6.num;

  LINE(236);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = typespecOPget_abs(t2, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            if (T_2_1.cell->tag == 5) T_2_2.num = true; else T_2_2.num = false;
            T_2_3.num = T_2_2.num ^ 1;
            if (T_2_3.num == true) {

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

  LINE(238);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
            CLUREF T_2_5;
            CLUREF T_2_6;
            err = idnOPget_str(i, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            err = typespecOPget_abs(t2, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            if (T_2_2.cell->tag != 5) {err = ERR_wrong_tag; goto ex_0;}
            T_2_3.num = T_2_2.cell->value;
            err = idnOPget_str(T_2_3, &T_2_4);
            if (err != ERR_ok) goto ex_0;
            T_2_5.num = ((T_2_1.str->size != T_2_4.str->size)? false :
                !(bcmp(T_2_1.str->data, T_2_4.str->data, T_2_1.str->size)));
            T_2_6.num = T_2_5.num ^ 1;
            if (T_2_6.num == true) {

  LINE(239);
                {
                {
                ret_1->tf = false;
                }
                {signal (ERR_ok);}}
                }
            else {

  LINE(240);
                {
                {
                ret_1->tf = true;
                }
                {signal (ERR_ok);}}
                }}/* end if */
            break;
            }
    case 1: 
         {

  LINE(243);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = typespecOPget_abs(t2, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            if (T_2_1.cell->tag == 1) T_2_2.num = true; else T_2_2.num = false;
            T_2_3.num = T_2_2.num ^ 1;
            if (T_2_3.num == true) {

  LINE(244);
                {
                {
                ret_1->tf = false;
                }
                {signal (ERR_ok);}}
                }
                }/* end if */
            break;
            }
    case 4: 
         {

  LINE(247);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = typespecOPget_abs(t2, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            if (T_2_1.cell->tag == 4) T_2_2.num = true; else T_2_2.num = false;
            T_2_3.num = T_2_2.num ^ 1;
            if (T_2_3.num == true) {

  LINE(248);
                {
                {
                ret_1->tf = false;
                }
                {signal (ERR_ok);}}
                }
                }/* end if */
            break;
            }
    case 9: 
         {

  LINE(251);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = typespecOPget_abs(t2, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            if (T_2_1.cell->tag == 9) T_2_2.num = true; else T_2_2.num = false;
            T_2_3.num = T_2_2.num ^ 1;
            if (T_2_3.num == true) {

  LINE(252);
                {
                {
                ret_1->tf = false;
                }
                {signal (ERR_ok);}}
                }
                }/* end if */
            break;
            }
    }
    }
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE typespec_similar ****/



/**** BEGIN PROCEDURE typelist_similar ****/

errcode typelist_similar(t1, t2, ret_1)
CLUREF t1;
CLUREF t2;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF i;
    enter_proc(257);

  LINE(258);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = t1.vec->size;
    T_1_2.num = t2.vec->size;
    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(259);
        {
        {
        ret_1->tf = false;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(260);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
        T_1_2.num = t1.vec->size; 
        for (T_1_1.num = 1; T_1_1.num <= T_1_2.num; T_1_1.num++) {
            i.num = T_1_1.num;

  LINE(261);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
            if (i.num < 1 || i.num > t1.vec->size ) {
                err = ERR_bounds;
                goto ex_0;}
            T_2_1.num = t1.vec->data[i.num - 1];
            if (i.num < 1 || i.num > t2.vec->size ) {
                err = ERR_bounds;
                goto ex_0;}
            T_2_2.num = t2.vec->data[i.num - 1];
            err = typespec_similar(T_2_1, T_2_2, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            T_2_4.num = T_2_3.num ^ 1;
            if (T_2_4.num == true) {

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

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

/**** END PROCEDURE typelist_similar ****/



/**** BEGIN PROCEDURE exceptionlist_similar ****/

errcode exceptionlist_similar(e1, e2, ret_1)
CLUREF e1;
CLUREF e2;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF i;
    enter_proc(268);

  LINE(269);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
    T_1_1.num = e1.vec->size;
    T_1_2.num = e2.vec->size;
    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(270);
        {
        {
        ret_1->tf = false;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(271);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
        T_1_2.num = e1.vec->size; 
        for (T_1_1.num = 1; T_1_1.num <= T_1_2.num; T_1_1.num++) {
            i.num = T_1_1.num;

  LINE(272);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
            CLUREF T_2_5;
            CLUREF T_2_6;
            if (i.num < 1 || i.num > e1.vec->size ) {
                err = ERR_bounds;
                goto ex_0;}
            T_2_1.num = e1.vec->data[i.num - 1];
            T_2_2.num = T_2_1.vec->data[0];
            if (i.num < 1 || i.num > e2.vec->size ) {
                err = ERR_bounds;
                goto ex_0;}
            T_2_3.num = e2.vec->data[i.num - 1];
            T_2_4.num = T_2_3.vec->data[0];
            T_2_5.num = ((T_2_2.str->size != T_2_4.str->size)? false :
                !(bcmp(T_2_2.str->data, T_2_4.str->data, T_2_2.str->size)));
            T_2_6.num = T_2_5.num ^ 1;
            if (T_2_6.num == true) {
                {
                {
                ret_1->tf = false;
                }
                {signal (ERR_ok);}}
                }
                }/* end if */

  LINE(273);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
            CLUREF T_2_5;
            CLUREF T_2_6;
            if (i.num < 1 || i.num > e1.vec->size ) {
                err = ERR_bounds;
                goto ex_0;}
            T_2_1.num = e1.vec->data[i.num - 1];
            T_2_2.num = T_2_1.vec->data[1];
            if (i.num < 1 || i.num > e2.vec->size ) {
                err = ERR_bounds;
                goto ex_0;}
            T_2_3.num = e2.vec->data[i.num - 1];
            T_2_4.num = T_2_3.vec->data[1];
            err = typelist_similar(T_2_2, T_2_4, &T_2_5);
            if (err != ERR_ok) goto ex_0;
            T_2_6.num = T_2_5.num ^ 1;
            if (T_2_6.num == true) {

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

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

/**** END PROCEDURE exceptionlist_similar ****/


CLUREF STR_var_012;
CLUREF STR_ownvar_012;
CLUREF STR_tparm_012;
CLUREF STR_vparm_012;
CLUREF STR_tconst_012;
CLUREF STR_expr_012;
CLUREF STR_typeset_012;
CLUREF STR_gen_012;
CLUREF STR_opgen_012;
static int idnkind_print_own_init = 0;

/**** BEGIN PROCEDURE idnkind_print ****/

errcode idnkind_print(i)
CLUREF i;
    {
    errcode err;
    errcode ecode2;
    CLUREF po;
        if (idnkind_print_own_init == 0) {
        stringOPcons("var\n", CLU_1, CLU_4, &STR_var_012);
        stringOPcons("ownvar\n", CLU_1, CLU_7, &STR_ownvar_012);
        stringOPcons("tparm\n", CLU_1, CLU_6, &STR_tparm_012);
        stringOPcons("vparm\n", CLU_1, CLU_6, &STR_vparm_012);
        stringOPcons("tconst\n", CLU_1, CLU_7, &STR_tconst_012);
        stringOPcons("expr\n", CLU_1, CLU_5, &STR_expr_012);
        stringOPcons("typeset\n", CLU_1, CLU_8, &STR_typeset_012);
        stringOPcons("gen\n", CLU_1, CLU_4, &STR_gen_012);
        stringOPcons("opgen\n", CLU_1, CLU_6, &STR_opgen_012);
        stringOPcons("unknown\n", CLU_1, CLU_8, &STR_unknown_012);
        idnkind_print_own_init = 1;
    }
    enter_proc(280);

  LINE(281);
    {
    if (false == true) {
        {
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(282);
    {
        {CLUREF T_1_1;
        err = get_stream(&T_1_1);
        if (err != ERR_ok) goto ex_0;
        po.num = T_1_1.num;
        }
        }

  LINE(283);
    {
    switch (i.cell->tag) {
    case 9: 
         {

  LINE(285);
            {
            err = streamOPputs(po, STR_var_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 4: 
         {

  LINE(287);
            {
            err = streamOPputs(po, STR_ownvar_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 6: 
         {

  LINE(289);
            {
            err = streamOPputs(po, STR_tparm_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 10: 
         {

  LINE(291);
            {
            err = streamOPputs(po, STR_vparm_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 5: 
         {

  LINE(293);
            {
            err = streamOPputs(po, STR_tconst_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 1: 
         {

  LINE(295);
            {
            err = streamOPputs(po, STR_expr_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 7: 
         {

  LINE(297);
            {
            err = streamOPputs(po, STR_typeset_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 2: 
         {

  LINE(299);
            {
            err = streamOPputs(po, STR_gen_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 3: 
         {

  LINE(301);
            {
            err = streamOPputs(po, STR_opgen_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 8: 
         {

  LINE(303);
            {
            err = streamOPputs(po, STR_unknown_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    }
    }
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE idnkind_print ****/


extern errcode streamOPprimary_output();
extern errcode ti_print();
extern errcode ti_print_1();
CLUREF STR_applyi_072_040parms_050size_051;
CLUREF STR_cluster_137_012;
CLUREF STR_atype_012;
static int duspec_print_own_init = 0;

/**** BEGIN PROCEDURE duspec_print ****/

errcode duspec_print(d, short_UNIQ)
CLUREF d;
CLUREF short_UNIQ;
    {
    errcode err;
    errcode ecode2;
    CLUREF po;
    CLUREF a;
    CLUREF ti;
        if (duspec_print_own_init == 0) {
        stringOPcons("applyi: parms(size)", CLU_1, CLU_19, &STR_applyi_072_040parms_050size_051);
        stringOPcons("\n", CLU_1, CLU_1, &STR__012);
        stringOPcons("cluster_\n", CLU_1, CLU_9, &STR_cluster_137_012);
        stringOPcons("select\n", CLU_1, CLU_7, &STR_select_012);
        stringOPcons("atype\n", CLU_1, CLU_6, &STR_atype_012);
        stringOPcons("none\n", CLU_1, CLU_5, &STR_none_012);
        duspec_print_own_init = 1;
    }
    enter_proc(307);

  LINE(308);
    {
    if (false == true) {
        {
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(309);
    {
        {CLUREF T_1_1;
        err = streamOPprimary_output(&T_1_1);
        if (err != ERR_ok) goto ex_0;
        po.num = T_1_1.num;
        }
        }

  LINE(310);
    {
    switch (d.cell->tag) {
    case 1: 
         {CLUREF T_1_1;
        T_1_1.num = d.cell->value;
        a.num = T_1_1.num;

  LINE(312);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
            CLUREF T_2_5;
            T_2_1.num = a.vec->data[0];
            T_2_2.num = T_2_1.vec->size;
            err = intOPunparse(T_2_2, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(STR_applyi_072_040parms_050size_051, T_2_3, &T_2_4);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_4, STR__012, &T_2_5);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_5);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(314);
            {
            CLUREF T_2_1;
            T_2_1.num = a.vec->data[1];
            err = typespec_print(T_2_1);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(315);
            {
            err = streamOPputs(po, STR__012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 3: 
         {CLUREF T_1_2;
        T_1_2.num = d.cell->value;
        ti.num = T_1_2.num;

  LINE(318);
            {
            err = streamOPputs(po, STR_cluster_137_012);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(319);
            {
            CLUREF T_2_1;
            T_2_1.num = short_UNIQ.num ^ 1;
            if (T_2_1.num == true) {
                {
                err = ti_print(ti);
                if (err != ERR_ok) goto ex_0;
                }
                }
                }/* end if */
            break;
            }
    case 5: 
         {

  LINE(321);
            {
            err = streamOPputs(po, STR_select_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 2: 
         {CLUREF T_1_3;
        T_1_3.num = d.cell->value;
        ti.num = T_1_3.num;

  LINE(323);
            {
            err = streamOPputs(po, STR_atype_012);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(324);
            {
            err = ti_print_1(ti);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 4: 
         {

  LINE(326);
            {
            err = streamOPputs(po, STR_none_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    }
    }
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE duspec_print ****/


extern errcode sequenceOPelements();
CLUREF STR_parms_072_012;
CLUREF STR__040;
CLUREF STR__012opers_072_012;
static int ti_print_own_init = 0;

/**** BEGIN PROCEDURE ti_print ****/

errcode ti_print(t)
CLUREF t;
    {
    errcode err;
    errcode ecode2;
    CLUREF po;
    CLUREF each_p;
    CLUREF each_op;
        if (ti_print_own_init == 0) {
        stringOPcons("parms:\n", CLU_1, CLU_7, &STR_parms_072_012);
        stringOPcons(" ", CLU_1, CLU_1, &STR__040);
        stringOPcons("\nopers:\n", CLU_1, CLU_8, &STR__012opers_072_012);
        stringOPcons("\n", CLU_1, CLU_1, &STR__012);
        ti_print_own_init = 1;
    }
    enter_proc(330);

  LINE(331);
    {
    if (false == true) {
        {
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(332);
    {
        {CLUREF T_1_1;
        err = get_stream(&T_1_1);
        if (err != ERR_ok) goto ex_0;
        po.num = T_1_1.num;
        }
        }

  LINE(333);
    {
    err = streamOPputs(po, STR_parms_072_012);
    if (err != ERR_ok) goto ex_0;
    }

  LINE(334);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
        T_1_1.num = t.vec->data[1];
        T_1_3.num = T_1_1.vec->size; 
        T_1_4 = T_1_1;
        for (T_1_2.num = 1; T_1_2.num <= T_1_3.num; T_1_2.num++) {
            each_p.num = T_1_4.vec->data[T_1_2.num - 1];

  LINE(335);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            err = idnOPget_str(each_p, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_1, STR__040, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_2);
            if (err != ERR_ok) goto ex_0;
            }
        }
    }
    end_inline_for_1:;

  LINE(336);
    {
    err = streamOPputs(po, STR__012opers_072_012);
    if (err != ERR_ok) goto ex_0;
    }

  LINE(337);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
        T_1_1.num = t.vec->data[0];
        T_1_3.num = T_1_1.vec->size; 
        T_1_4 = T_1_1;
        for (T_1_2.num = 1; T_1_2.num <= T_1_3.num; T_1_2.num++) {
            each_op.num = T_1_4.vec->data[T_1_2.num - 1];

  LINE(338);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            T_2_1.num = each_op.vec->data[1];
            err = stringOPconcat(T_2_1, STR__040, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_2);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(339);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            T_2_1.num = each_op.vec->data[0];
            T_2_2.num = T_2_1.vec->data[1];
            err = typespec_print(T_2_2);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(340);
            {
            err = streamOPputs(po, STR__012);
            if (err != ERR_ok) goto ex_0;
            }
        }
    }
    end_inline_for_2:;

  LINE(342);
    {
    err = streamOPputs(po, STR__012);
    if (err != ERR_ok) goto ex_0;
    }
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE ti_print ****/


static int ti_print_1_own_init = 0;

/**** BEGIN PROCEDURE ti_print_1 ****/

errcode ti_print_1(t)
CLUREF t;
    {
    errcode err;
    errcode ecode2;
    CLUREF po;
    CLUREF each_p;
    CLUREF each_op;
        if (ti_print_1_own_init == 0) {
        stringOPcons("parms:\n", CLU_1, CLU_7, &STR_parms_072_012);
        stringOPcons(" ", CLU_1, CLU_1, &STR__040);
        stringOPcons("\nopers:\n", CLU_1, CLU_8, &STR__012opers_072_012);
        stringOPcons("\n", CLU_1, CLU_1, &STR__012);
        ti_print_1_own_init = 1;
    }
    enter_proc(345);

  LINE(346);
    {
    if (false == true) {
        {
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(347);
    {
        {CLUREF T_1_1;
        err = get_stream(&T_1_1);
        if (err != ERR_ok) goto ex_0;
        po.num = T_1_1.num;
        }
        }

  LINE(348);
    {
    err = streamOPputs(po, STR_parms_072_012);
    if (err != ERR_ok) goto ex_0;
    }

  LINE(349);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
        T_1_1.num = t.vec->data[1];
        T_1_3.num = T_1_1.vec->size; 
        T_1_4 = T_1_1;
        for (T_1_2.num = 1; T_1_2.num <= T_1_3.num; T_1_2.num++) {
            each_p.num = T_1_4.vec->data[T_1_2.num - 1];

  LINE(350);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            err = idnOPget_str(each_p, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_1, STR__040, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_2);
            if (err != ERR_ok) goto ex_0;
            }
        }
    }
    end_inline_for_1:;

  LINE(351);
    {
    err = streamOPputs(po, STR__012opers_072_012);
    if (err != ERR_ok) goto ex_0;
    }

  LINE(352);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CLUREF T_1_4;
        T_1_1.num = t.vec->data[0];
        T_1_3.num = T_1_1.vec->size; 
        T_1_4 = T_1_1;
        for (T_1_2.num = 1; T_1_2.num <= T_1_3.num; T_1_2.num++) {
            each_op.num = T_1_4.vec->data[T_1_2.num - 1];

  LINE(353);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            T_2_1.num = each_op.vec->data[1];
            err = stringOPconcat(T_2_1, STR__040, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_2);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(354);
            {
            err = streamOPputs(po, STR__012);
            if (err != ERR_ok) goto ex_0;
            }
        }
    }
    end_inline_for_2:;

  LINE(356);
    {
    err = streamOPputs(po, STR__012);
    if (err != ERR_ok) goto ex_0;
    }
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE ti_print_1 ****/


extern errcode stmtOPget_abs();
CLUREF STR_decl_012;
CLUREF STR_declinit_012;
CLUREF STR_assn_012;
CLUREF STR_invoke_012;
CLUREF STR_while_137_012;
CLUREF STR_for_137_012;
CLUREF STR_if_137_012;
CLUREF STR_tag_137_012;
CLUREF STR_return_137_012;
CLUREF STR_yield_137_012;
CLUREF STR_signal_137_012;
CLUREF STR_exit_137_012;
CLUREF STR_break_137_012;
CLUREF STR_continue_137_012;
CLUREF STR_body_012;
CLUREF STR_except_137_012;
CLUREF STR_resignal_137_012;
static int stmt_print_own_init = 0;

/**** BEGIN PROCEDURE stmt_print ****/

errcode stmt_print(s)
CLUREF s;
    {
    errcode err;
    errcode ecode2;
    CLUREF po;
    CLUREF sa;
        if (stmt_print_own_init == 0) {
        stringOPcons("decl\n", CLU_1, CLU_5, &STR_decl_012);
        stringOPcons("declinit\n", CLU_1, CLU_9, &STR_declinit_012);
        stringOPcons("assn\n", CLU_1, CLU_5, &STR_assn_012);
        stringOPcons("invoke\n", CLU_1, CLU_7, &STR_invoke_012);
        stringOPcons("while_\n", CLU_1, CLU_7, &STR_while_137_012);
        stringOPcons("for_\n", CLU_1, CLU_5, &STR_for_137_012);
        stringOPcons("if_\n", CLU_1, CLU_4, &STR_if_137_012);
        stringOPcons("tag_\n", CLU_1, CLU_5, &STR_tag_137_012);
        stringOPcons("return_\n", CLU_1, CLU_8, &STR_return_137_012);
        stringOPcons("yield_\n", CLU_1, CLU_7, &STR_yield_137_012);
        stringOPcons("signal_\n", CLU_1, CLU_8, &STR_signal_137_012);
        stringOPcons("exit_\n", CLU_1, CLU_6, &STR_exit_137_012);
        stringOPcons("break_\n", CLU_1, CLU_7, &STR_break_137_012);
        stringOPcons("continue_\n", CLU_1, CLU_10, &STR_continue_137_012);
        stringOPcons("body\n", CLU_1, CLU_5, &STR_body_012);
        stringOPcons("except_\n", CLU_1, CLU_8, &STR_except_137_012);
        stringOPcons("resignal_\n", CLU_1, CLU_10, &STR_resignal_137_012);
        stmt_print_own_init = 1;
    }
    enter_proc(359);

  LINE(360);
    {
    if (false == true) {
        {
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(361);
    {
        {CLUREF T_1_1;
        err = get_stream(&T_1_1);
        if (err != ERR_ok) goto ex_0;
        po.num = T_1_1.num;
        }
        }

  LINE(362);
    {
    CLUREF T_1_1;
    err = stmtOPget_abs(s, &T_1_1);
    if (err != ERR_ok) goto ex_0;
    switch (T_1_1.cell->tag) {
    case 6: 
         {CLUREF T_1_2;
        T_1_2.num = T_1_1.cell->value;
        sa.num = T_1_2.num;

  LINE(364);
            {
            err = streamOPputs(po, STR_decl_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 7: 
         {CLUREF T_1_3;
        T_1_3.num = T_1_1.cell->value;
        sa.num = T_1_3.num;

  LINE(366);
            {
            err = streamOPputs(po, STR_declinit_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 1: 
         {CLUREF T_1_4;
        T_1_4.num = T_1_1.cell->value;
        sa.num = T_1_4.num;

  LINE(368);
            {
            err = streamOPputs(po, STR_assn_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 13: 
         {CLUREF T_1_5;
        T_1_5.num = T_1_1.cell->value;
        sa.num = T_1_5.num;

  LINE(370);
            {
            err = streamOPputs(po, STR_invoke_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 19: 
         {CLUREF T_1_6;
        T_1_6.num = T_1_1.cell->value;
        sa.num = T_1_6.num;

  LINE(372);
            {
            err = streamOPputs(po, STR_while_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 10: 
         {CLUREF T_1_7;
        T_1_7.num = T_1_1.cell->value;
        sa.num = T_1_7.num;

  LINE(374);
            {
            err = streamOPputs(po, STR_for_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 12: 
         {CLUREF T_1_8;
        T_1_8.num = T_1_1.cell->value;
        sa.num = T_1_8.num;

  LINE(376);
            {
            err = streamOPputs(po, STR_if_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 18: 
         {CLUREF T_1_9;
        T_1_9.num = T_1_1.cell->value;
        sa.num = T_1_9.num;

  LINE(378);
            {
            err = streamOPputs(po, STR_tag_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 15: 
         {CLUREF T_1_10;
        T_1_10.num = T_1_1.cell->value;
        sa.num = T_1_10.num;

  LINE(380);
            {
            err = streamOPputs(po, STR_return_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 20: 
         {CLUREF T_1_11;
        T_1_11.num = T_1_1.cell->value;
        sa.num = T_1_11.num;

  LINE(382);
            {
            err = streamOPputs(po, STR_yield_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 16: 
         {CLUREF T_1_12;
        T_1_12.num = T_1_1.cell->value;
        sa.num = T_1_12.num;

  LINE(384);
            {
            err = streamOPputs(po, STR_signal_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 9: 
         {CLUREF T_1_13;
        T_1_13.num = T_1_1.cell->value;
        sa.num = T_1_13.num;

  LINE(386);
            {
            err = streamOPputs(po, STR_exit_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 4: 
         {

  LINE(388);
            {
            err = streamOPputs(po, STR_break_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 5: 
         {

  LINE(390);
            {
            err = streamOPputs(po, STR_continue_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 3: 
         {CLUREF T_1_14;
        T_1_14.num = T_1_1.cell->value;
        sa.num = T_1_14.num;

  LINE(392);
            {
            err = streamOPputs(po, STR_body_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 8: 
         {CLUREF T_1_15;
        T_1_15.num = T_1_1.cell->value;
        sa.num = T_1_15.num;

  LINE(394);
            {
            err = streamOPputs(po, STR_except_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 14: 
         {CLUREF T_1_16;
        T_1_16.num = T_1_1.cell->value;
        sa.num = T_1_16.num;

  LINE(396);
            {
            err = streamOPputs(po, STR_resignal_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    default: {
    }
    }
    }
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE stmt_print ****/


extern errcode exprOPget_abs();
extern errcode realOPunparse();
extern errcode stringOPc2s();
extern errcode exprOPget_typespec();
CLUREF STR_expr_137;
CLUREF STR__072_040;
CLUREF STR_cand_137_012;
CLUREF STR_cor_137_012;
CLUREF STR_invoke_072_012;
CLUREF STR_s_137cons_012;
CLUREF STR_apply_040_072_040;
CLUREF STR__040parms_050size_051;
CLUREF STR_op_040_072_040;
CLUREF STR__040_040parms_050size_051_072;
CLUREF STR_up_137_012;
CLUREF STR_down_137_012;
CLUREF STR_type_137of_137_012;
CLUREF STR_null_012;
CLUREF STR_bool_012;
CLUREF STR_int_072_040;
CLUREF STR_real_072_040;
CLUREF STR_char_072_040;
CLUREF STR_str_072_040;
CLUREF STR_unknown_040expr_040type_012;
CLUREF STR__055_055_055_040;
static int expr_print_own_init = 0;

/**** BEGIN PROCEDURE expr_print ****/

errcode expr_print(exp, stage)
CLUREF exp;
CLUREF stage;
    {
    errcode err;
    errcode ecode2;
    CLUREF po;
    CLUREF id;
    CLUREF xa;
    CLUREF inv;
    CLUREF specs;
    CLUREF b;
    CLUREF i;
    CLUREF r;
    CLUREF c;
    CLUREF s;
        if (expr_print_own_init == 0) {
        stringOPcons("expr_", CLU_1, CLU_5, &STR_expr_137);
        stringOPcons(": ", CLU_1, CLU_2, &STR__072_040);
        stringOPcons("idn: ", CLU_1, CLU_5, &STR_idn_072_040);
        stringOPcons("\n", CLU_1, CLU_1, &STR__012);
        stringOPcons("any_\n", CLU_1, CLU_5, &STR_any_137_012);
        stringOPcons("cand_\n", CLU_1, CLU_6, &STR_cand_137_012);
        stringOPcons("cor_\n", CLU_1, CLU_5, &STR_cor_137_012);
        stringOPcons("invoke:\n", CLU_1, CLU_8, &STR_invoke_072_012);
        stringOPcons("a_cons\n", CLU_1, CLU_7, &STR_a_137cons_012);
        stringOPcons("s_cons\n", CLU_1, CLU_7, &STR_s_137cons_012);
        stringOPcons("apply : ", CLU_1, CLU_8, &STR_apply_040_072_040);
        stringOPcons(" parms(size)", CLU_1, CLU_12, &STR__040parms_050size_051);
        stringOPcons("none\n", CLU_1, CLU_5, &STR_none_012);
        stringOPcons("op : ", CLU_1, CLU_5, &STR_op_040_072_040);
        stringOPcons("  parms(size):", CLU_1, CLU_14, &STR__040_040parms_050size_051_072);
        stringOPcons("\n      ", CLU_1, CLU_7, &STR__012_040_040_040_040_040_040);
        stringOPcons("force_\n", CLU_1, CLU_7, &STR_force_137_012);
        stringOPcons("up_\n", CLU_1, CLU_4, &STR_up_137_012);
        stringOPcons("down_\n", CLU_1, CLU_6, &STR_down_137_012);
        stringOPcons("type_\n", CLU_1, CLU_6, &STR_type_137_012);
        stringOPcons("type_of_\n", CLU_1, CLU_9, &STR_type_137of_137_012);
        stringOPcons("null\n", CLU_1, CLU_5, &STR_null_012);
        stringOPcons("bool\n", CLU_1, CLU_5, &STR_bool_012);
        stringOPcons("int: ", CLU_1, CLU_5, &STR_int_072_040);
        stringOPcons("real: ", CLU_1, CLU_6, &STR_real_072_040);
        stringOPcons("char: ", CLU_1, CLU_6, &STR_char_072_040);
        stringOPcons("str: ", CLU_1, CLU_5, &STR_str_072_040);
        stringOPcons("unknown expr type\n", CLU_1, CLU_18, &STR_unknown_040expr_040type_012);
        stringOPcons("--- ", CLU_1, CLU_4, &STR__055_055_055_040);
        expr_print_own_init = 1;
    }
    enter_proc(401);

  LINE(402);
    {
    if (false == true) {
        {
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(403);
    {
        {CLUREF T_1_1;
        err = get_stream(&T_1_1);
        if (err != ERR_ok) goto ex_0;
        po.num = T_1_1.num;
        }
        }

  LINE(404);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    err = intOPunparse(stage, &T_1_1);
    if (err != ERR_ok) goto ex_0;
    err = stringOPconcat(STR_expr_137, T_1_1, &T_1_2);
    if (err != ERR_ok) goto ex_0;
    err = stringOPconcat(T_1_2, STR__072_040, &T_1_3);
    if (err != ERR_ok) goto ex_0;
    err = streamOPputs(po, T_1_3);
    if (err != ERR_ok) goto ex_0;
    }

  LINE(405);
    {
    CLUREF T_1_1;
    err = exprOPget_abs(exp, &T_1_1);
    if (err != ERR_ok) goto ex_0;
    switch (T_1_1.cell->tag) {
    case 13: 
         {CLUREF T_1_2;
        T_1_2.num = T_1_1.cell->value;
        id.num = T_1_2.num;

  LINE(407);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = idnOPget_str(id, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(STR_idn_072_040, T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_2, STR__012, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_3);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 2: 
         {CLUREF T_1_3;
        T_1_3.num = T_1_1.cell->value;
        xa.num = T_1_3.num;

  LINE(409);
            {
            err = streamOPputs(po, STR_any_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 6: 
         {CLUREF T_1_4;
        T_1_4.num = T_1_1.cell->value;
        xa.num = T_1_4.num;

  LINE(411);
            {
            err = streamOPputs(po, STR_cand_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 8: 
         {CLUREF T_1_5;
        T_1_5.num = T_1_1.cell->value;
        xa.num = T_1_5.num;

  LINE(413);
            {
            err = streamOPputs(po, STR_cor_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 16: 
         {CLUREF T_1_6;
        T_1_6.num = T_1_1.cell->value;
        inv.num = T_1_6.num;

  LINE(415);
            {
            err = streamOPputs(po, STR_invoke_072_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 1: 
         {CLUREF T_1_7;
        T_1_7.num = T_1_1.cell->value;
        xa.num = T_1_7.num;

  LINE(417);
            {
            err = streamOPputs(po, STR_a_137cons_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 23: 
         {CLUREF T_1_8;
        T_1_8.num = T_1_1.cell->value;
        xa.num = T_1_8.num;

  LINE(419);
            {
            err = streamOPputs(po, STR_s_137cons_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 3: 
         {CLUREF T_1_9;
        T_1_9.num = T_1_1.cell->value;
        xa.num = T_1_9.num;

  LINE(421);
            {
            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;
            T_2_1.num = xa.vec->data[0];
            err = duOPget_common(T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(STR_apply_040_072_040, T_2_2, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_3, STR__040parms_050size_051, &T_2_4);
            if (err != ERR_ok) goto ex_0;
            T_2_5.num = xa.vec->data[1];
            T_2_6.num = T_2_5.vec->size;
            err = intOPunparse(T_2_6, &T_2_7);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_4, T_2_7, &T_2_8);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_8, STR__012, &T_2_9);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_9);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(424);
            {
                {CLUREF T_2_1;
                CLUREF T_2_2;
                CLUREF T_2_3;
                T_2_1.num = xa.vec->data[0];
                err = duOPread_specs(T_2_1, &T_2_2, &T_2_3);
                if (err != ERR_ok) goto ex_0;
                specs.num = T_2_2.num;
                b.num = T_2_3.num;
                }
                }

  LINE(425);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            if (specs.cell->tag == 4) T_2_1.num = true; else T_2_1.num = false;
            T_2_2.num = T_2_1.num ^ 1;
            if (T_2_2.num == true) {

  LINE(426);
                {
                err = duspec_print(specs, CLU_1);
                if (err != ERR_ok) goto ex_0;
                }
                }
            else {

  LINE(428);
                {
                err = streamOPputs(po, STR_none_012);
                if (err != ERR_ok) goto ex_0;
                }
                }}/* end if */

  LINE(430);
            {
            err = streamOPputs(po, STR__012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 20: 
         {CLUREF T_1_10;
        T_1_10.num = T_1_1.cell->value;
        xa.num = T_1_10.num;

  LINE(432);
            {
            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 = xa.vec->data[0];
            err = stringOPconcat(STR_op_040_072_040, T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_2, STR__040_040parms_050size_051_072, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            T_2_4.num = xa.vec->data[1];
            T_2_5.num = T_2_4.vec->size;
            err = intOPunparse(T_2_5, &T_2_6);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_3, T_2_6, &T_2_7);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_7, STR__012_040_040_040_040_040_040, &T_2_8);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_8);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(434);
            {
            CLUREF T_2_1;
            T_2_1.num = xa.vec->data[2];
            err = typespec_print(T_2_1);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(435);
            {
            err = streamOPputs(po, STR__012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 11: 
         {CLUREF T_1_11;
        T_1_11.num = T_1_1.cell->value;
        xa.num = T_1_11.num;

  LINE(437);
            {
            err = streamOPputs(po, STR_force_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 27: 
         {CLUREF T_1_12;
        T_1_12.num = T_1_1.cell->value;
        xa.num = T_1_12.num;

  LINE(439);
            {
            err = streamOPputs(po, STR_up_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 9: 
         {CLUREF T_1_13;
        T_1_13.num = T_1_1.cell->value;
        xa.num = T_1_13.num;

  LINE(441);
            {
            err = streamOPputs(po, STR_down_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 25: 
         {CLUREF T_1_14;
        T_1_14.num = T_1_1.cell->value;
        xa.num = T_1_14.num;

  LINE(443);
            {
            err = streamOPputs(po, STR_type_137_012);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(444);
            {
            err = typespec_print(xa);
            if (err != ERR_ok) goto ex_0;
            }

  LINE(445);
            {
            err = streamOPputs(po, STR__012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 26: 
         {CLUREF T_1_15;
        T_1_15.num = T_1_1.cell->value;
        xa.num = T_1_15.num;

  LINE(447);
            {
            err = streamOPputs(po, STR_type_137of_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 19: 
         {

  LINE(449);
            {
            err = streamOPputs(po, STR_null_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 5: 
         {

  LINE(451);
            {
            err = streamOPputs(po, STR_bool_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 15: 
         {CLUREF T_1_16;
        T_1_16.num = T_1_1.cell->value;
        i.num = T_1_16.num;

  LINE(453);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = intOPunparse(i, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(STR_int_072_040, T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_2, STR__012, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_3);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 21: 
         {CLUREF T_1_17;
        T_1_17.num = T_1_1.cell->value;
        r.num = T_1_17.num;

  LINE(455);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = realOPunparse(r, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(STR_real_072_040, T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_2, STR__012, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_3);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 7: 
         {CLUREF T_1_18;
        T_1_18.num = T_1_1.cell->value;
        c.num = T_1_18.num;

  LINE(457);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            err = stringOPc2s(c, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(STR_char_072_040, T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_2, STR__012, &T_2_3);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_3);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 24: 
         {CLUREF T_1_19;
        T_1_19.num = T_1_1.cell->value;
        s.num = T_1_19.num;

  LINE(459);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            err = stringOPconcat(STR_str_072_040, s, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            err = stringOPconcat(T_2_1, STR__012, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = streamOPputs(po, T_2_2);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    default: {

  LINE(461);
        {
        err = streamOPputs(po, STR_unknown_040expr_040type_012);
        if (err != ERR_ok) goto ex_0;
        }
    }
    }
    }

  LINE(463);
    {
    err = streamOPputs(po, STR__055_055_055_040);
    if (err != ERR_ok) goto ex_0;
    }

  LINE(464);
    {
    CLUREF T_1_1;
    err = exprOPget_typespec(exp, &T_1_1);
    if (err != ERR_ok) goto ex_0;
    err = typespec_print(T_1_1);
    if (err != ERR_ok) goto ex_0;
    }
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE expr_print ****/


static int other_print_own_init = 0;

/**** BEGIN PROCEDURE other_print ****/

errcode other_print(o)
CLUREF o;
    {
    errcode err;
    errcode ecode2;
    CLUREF po;
        if (other_print_own_init == 0) {
        stringOPcons("du\n", CLU_1, CLU_3, &STR_du_012);
        stringOPcons("op\n", CLU_1, CLU_3, &STR_op_012);
        stringOPcons("return_\n", CLU_1, CLU_8, &STR_return_137_012);
        other_print_own_init = 1;
    }
    enter_proc(468);

  LINE(469);
    {
    if (false == true) {
        {
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(470);
    {
        {CLUREF T_1_1;
        err = get_stream(&T_1_1);
        if (err != ERR_ok) goto ex_0;
        po.num = T_1_1.num;
        }
        }

  LINE(471);
    {
    switch (o.cell->tag) {
    case 1: 
         {

  LINE(473);
            {
            err = streamOPputs(po, STR_du_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 2: 
         {

  LINE(475);
            {
            err = streamOPputs(po, STR_op_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 3: 
         {

  LINE(477);
            {
            err = streamOPputs(po, STR_return_137_012);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    }
    }
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE other_print ****/


CLUREF STR_Probable_040compiler_040bug_040;
static int compiler_logit_own_init = 0;

/**** BEGIN PROCEDURE compiler_logit ****/

errcode compiler_logit(code, s)
CLUREF code;
CLUREF s;
    {
    errcode err;
    errcode ecode2;
    CLUREF po;
        if (compiler_logit_own_init == 0) {
        stringOPcons("\n", CLU_1, CLU_1, &STR__012);
        stringOPcons("Probable compiler bug ", CLU_1, CLU_22, &STR_Probable_040compiler_040bug_040);
        compiler_logit_own_init = 1;
    }
    enter_proc(481);

  LINE(482);
    {
        {CLUREF T_1_1;
        err = get_stream(&T_1_1);
        if (err != ERR_ok) goto ex_0;
        po.num = T_1_1.num;
        }
        }

  LINE(483);
    {
    if (true == true) {
        {
        CLUREF T_2_1;
        err = stringOPconcat(s, STR__012, &T_2_1);
        if (err != ERR_ok) goto ex_0;
        err = streamOPputs(po, T_2_1);
        if (err != ERR_ok) goto ex_0;
        }
        }
    else {

  LINE(484);
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        CLUREF T_2_3;
        err = intOPunparse(code, &T_2_1);
        if (err != ERR_ok) goto ex_0;
        err = stringOPconcat(STR_Probable_040compiler_040bug_040, T_2_1, &T_2_2);
        if (err != ERR_ok) goto ex_0;
        err = stringOPconcat(T_2_2, STR__012, &T_2_3);
        if (err != ERR_ok) goto ex_0;
        err = streamOPputs(po, T_2_3);
        if (err != ERR_ok) goto ex_0;
        }
        }}/* end if */
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE compiler_logit ****/



/**** BEGIN PROCEDURE get_stream ****/

errcode get_stream(ret_1)
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    enter_proc(489);

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

/**** END PROCEDURE get_stream ****/



typedef struct {
int count;
} array_extend_of_t_REQS;

array_extend_of_t_REQS array_extend_of_t_reqs_actual = {0};

struct REQS * array_extend_of_t_reqs = (struct REQS *)&array_extend_of_t_reqs_actual;


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

extern errcode arrayOPaddh();

typedef struct {
    int array_extend_own_init;
    array_extend_of_t_OPS *t_ops;
    } array_extend_OWN_DEFN;
OWN_req array_extend_ownreqs = {sizeof(array_extend_OWN_DEFN), 1};


/**** BEGIN PROCEDURE array_extend ****/

errcode array_extend(a, b)
CLUREF a;
CLUREF b;
    {
    errcode err;
    errcode ecode2;
    array_extend_OWN_DEFN *op_own_ptr;
    CLUREF elt;
    op_own_ptr = (array_extend_OWN_DEFN*) CUR_PROC_VAR.proc->op_owns;
        if (op_own_ptr->array_extend_own_init == 0) {
        op_own_ptr->array_extend_own_init = 1;
    }
    enter_proc(498);

  LINE(499);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
        T_1_2.num = b.vec->size; 
        T_1_3 = b;
        for (T_1_1.num = 1; T_1_1.num <= T_1_2.num; T_1_1.num++) {
            elt.num = T_1_3.vec->data[T_1_1.num - 1];

  LINE(500);
            {
            {
            if ((a.array->int_low + a.array->ext_size + 1) < a.array->int_size) {
                a.array->store->data[a.array->int_low + a.array->ext_size] = elt.num;
                a.array->ext_size++; a.array->ext_high++;}
            else {
                err = arrayOPaddh(a, elt);
                if (err != ERR_ok) goto ex_0;}
            }
            }
        }
    }
    end_inline_for_1:;
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE array_extend ****/



typedef struct {
int count;
} array_concat_of_t_REQS;

array_concat_of_t_REQS array_concat_of_t_reqs_actual = {0};

struct REQS * array_concat_of_t_reqs = (struct REQS *)&array_concat_of_t_reqs_actual;


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

extern errcode arrayOPelements();

typedef struct {
    int array_concat_own_init;
    array_concat_of_t_OPS *t_ops;
    } array_concat_OWN_DEFN;
OWN_req array_concat_ownreqs = {sizeof(array_concat_OWN_DEFN), 1};


/**** BEGIN PROCEDURE array_concat ****/

errcode array_concat(a, b)
CLUREF a;
CLUREF b;
    {
    errcode err;
    errcode ecode2;
    array_concat_OWN_DEFN *op_own_ptr;
    CLUREF elt;
    op_own_ptr = (array_concat_OWN_DEFN*) CUR_PROC_VAR.proc->op_owns;
        if (op_own_ptr->array_concat_own_init == 0) {
        op_own_ptr->array_concat_own_init = 1;
    }
    enter_proc(504);

  LINE(505);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
        T_1_2.num = b.array->ext_high; 
        T_1_3 = b;
        for (T_1_1.num = b.array->ext_low; T_1_1.num <= T_1_2.num; T_1_1.num++) {
            if (T_1_1.num > T_1_3.array->ext_high || T_1_1.num < T_1_3.array->ext_low) {
                err = ERR_failure;
                elist[0].str = array_bounds_exception_STRING;
                goto ex_0;}
            elt.num = T_1_3.array->store->data[T_1_1.num - T_1_3.array->ext_low + T_1_3.array->int_low];

  LINE(506);
            {
            {
            if ((a.array->int_low + a.array->ext_size + 1) < a.array->int_size) {
                a.array->store->data[a.array->int_low + a.array->ext_size] = elt.num;
                a.array->ext_size++; a.array->ext_high++;}
            else {
                err = arrayOPaddh(a, elt);
                if (err != ERR_ok) goto ex_0;}
            }
            }
        }
    }
    end_inline_for_1:;
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE array_concat ****/



typedef struct {
int count;
    char *copy_name;
} seq_extend_of_t_REQS;

seq_extend_of_t_REQS seq_extend_of_t_reqs_actual = {1,
    "copy"};

struct REQS * seq_extend_of_t_reqs = (struct REQS *)&seq_extend_of_t_reqs_actual;

typedef struct {
    int count;
    OWNPTR type_owns;
    OWNPTR op_owns;
    struct OP_ENTRY copy;
} seq_extend_of_t_OPS;
extern errcode sequenceOPcopy();
extern errcode sequenceOPaddh();

typedef struct {
    int seq_extend_own_init;
    seq_extend_of_t_OPS *t_ops;
    struct OPS *sequence_of_t_table;
    struct OPS *sequence_of_t_ops;
    OWNPTR sequence_of_t_owns;
    } seq_extend_OWN_DEFN;
OWN_req seq_extend_ownreqs = {sizeof(seq_extend_OWN_DEFN), 1};


/**** BEGIN PROCEDURE seq_extend ****/

errcode seq_extend(a, b, ret_1)
CLUREF a;
CLUREF b;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    seq_extend_OWN_DEFN *op_own_ptr;
    CLUREF c;
    CLUREF elt;
    op_own_ptr = (seq_extend_OWN_DEFN*) CUR_PROC_VAR.proc->op_owns;
        if (op_own_ptr->seq_extend_own_init == 0) {
        add_parm_info_type(0, op_own_ptr->t_ops, sequence_of_t_reqs);
        find_type_instance(sequence_ops, 1, &sequence_ownreqs, &(op_own_ptr->sequence_of_t_ops));
        }
        if (op_own_ptr->seq_extend_own_init == 0) {
        op_own_ptr->seq_extend_own_init = 1;
    }
    enter_proc(510);

  LINE(512);
    {
        {CLUREF T_1_1;
        generic_CLU_proc.type_owns = op_own_ptr->sequence_of_t_ops->type_owns;
        generic_CLU_proc.proc = sequenceOPcopy;
        CUR_PROC_VAR.proc = &generic_CLU_proc;
        err = sequenceOPcopy(a, &T_1_1);
        if (err != ERR_ok) goto ex_0;
        c.num = T_1_1.num;
        }
        }

  LINE(513);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
        T_1_2.num = b.vec->size; 
        T_1_3 = b;
        for (T_1_1.num = 1; T_1_1.num <= T_1_2.num; T_1_1.num++) {
            elt.num = T_1_3.vec->data[T_1_1.num - 1];

  LINE(514);
            {
            CLUREF T_2_1;
            err = sequenceOPaddh(c, elt, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            c.num = T_2_1.num;
            }
        }
    }
    end_inline_for_1:;

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

/**** END PROCEDURE seq_extend ****/


extern errcode sequenceOPnew();
extern errcode oneofOPmake_6();
extern errcode stmtOPcreate();
extern errcode oneofOPmake_7();

/**** BEGIN PROCEDURE initlist_to_stmtlist ****/

errcode initlist_to_stmtlist(i, ret_1)
CLUREF i;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF s;
    CLUREF each_init;
    CLUREF d;
    CLUREF this_abs;
    CLUREF this_stmt;
    CLUREF di;
    enter_proc(522);

  LINE(524);
    {
        {CLUREF T_1_1;
        err = sequenceOPnew(&T_1_1);
        if (err != ERR_ok) goto ex_0;
        s.num = T_1_1.num;
        }
        }

  LINE(525);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
        T_1_2.num = i.vec->size; 
        T_1_3 = i;
        for (T_1_1.num = 1; T_1_1.num <= T_1_2.num; T_1_1.num++) {
            each_init.num = T_1_3.vec->data[T_1_1.num - 1];

  LINE(526);
            {
            CLUREF T_2_1;
            T_2_1.num = each_init.vec->data[1];
            switch (T_2_1.cell->tag) {
            case 1: 
                 {CLUREF T_2_2;
                T_2_2.num = T_2_1.cell->value;
                d.num = T_2_2.num;

  LINE(528);
                    {
                        {CLUREF T_3_1;
                        CellAlloc(6, d.num, T_3_1);
                        this_abs.num = T_3_1.num;
                        }
                        }

  LINE(529);
                    {
                        {CLUREF T_3_1;
                        CLUREF T_3_2;
                        T_3_1.num = each_init.vec->data[0];
                        err = stmtOPcreate(this_abs, T_3_1, &T_3_2);
                        if (err != ERR_ok) goto ex_0;
                        this_stmt.num = T_3_2.num;
                        }
                        }

  LINE(530);
                    {
                    CLUREF T_3_1;
                    err = sequenceOPaddh(s, this_stmt, &T_3_1);
                    if (err != ERR_ok) goto ex_0;
                    s.num = T_3_1.num;
                    }
                    break;
                    }
            case 2: 
                 {CLUREF T_2_3;
                T_2_3.num = T_2_1.cell->value;
                di.num = T_2_3.num;

  LINE(532);
                    {
                        {CLUREF T_3_1;
                        CellAlloc(7, di.num, T_3_1);
                        this_abs.num = T_3_1.num;
                        }
                        }

  LINE(533);
                    {
                        {CLUREF T_3_1;
                        CLUREF T_3_2;
                        T_3_1.num = each_init.vec->data[0];
                        err = stmtOPcreate(this_abs, T_3_1, &T_3_2);
                        if (err != ERR_ok) goto ex_0;
                        this_stmt.num = T_3_2.num;
                        }
                        }

  LINE(534);
                    {
                    CLUREF T_3_1;
                    err = sequenceOPaddh(s, this_stmt, &T_3_1);
                    if (err != ERR_ok) goto ex_0;
                    s.num = T_3_1.num;
                    }
                    break;
                    }
            }
            }
        }
    }
    end_inline_for_1:;

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

/**** END PROCEDURE initlist_to_stmtlist ****/



typedef struct {
int count;
    char *elements_name;
} g_commalist_of_ltype_REQS;

g_commalist_of_ltype_REQS g_commalist_of_ltype_reqs_actual = {1,
    "elements"};

struct REQS * g_commalist_of_ltype_reqs = (struct REQS *)&g_commalist_of_ltype_reqs_actual;

typedef struct {
    int count;
    OWNPTR type_owns;
    OWNPTR op_owns;
    struct OP_ENTRY elements;
} g_commalist_of_ltype_OPS;

typedef struct {
int count;
} g_commalist_of_elt_REQS;

g_commalist_of_elt_REQS g_commalist_of_elt_reqs_actual = {0};

struct REQS * g_commalist_of_elt_reqs = (struct REQS *)&g_commalist_of_elt_reqs_actual;


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

extern errcode g_commalist_IB_1();
extern errcode elements();
extern errcode g_envOPputs();

typedef struct {
    int g_commalist_own_init;
    g_commalist_of_ltype_OPS *ltype_ops;
    g_commalist_of_elt_OPS *elt_ops;
    } g_commalist_OWN_DEFN;
OWN_req g_commalist_ownreqs = {sizeof(g_commalist_OWN_DEFN), 1};


/**** BEGIN PROCEDURE g_commalist ****/

errcode g_commalist(e, l, eltproc)
CLUREF e;
CLUREF l;
CLUREF eltproc;
    {
    struct {
        errcode err;
        errcode ecode2;
        g_commalist_OWN_DEFN *op_own_ptr;
        CLUREF first;
        CLUREF x;
        CLUREF e;
        CLUREF l;
        CLUREF eltproc;
        } locals;
    locals.e = e;
    locals.l = l;
    locals.eltproc = eltproc;
    locals.op_own_ptr = (g_commalist_OWN_DEFN*) CUR_PROC_VAR.proc->op_owns;
        if (locals.op_own_ptr->g_commalist_own_init == 0) {
        stringOPcons(", ", CLU_1, CLU_2, &STR__054_040);
        }
        if (locals.op_own_ptr->g_commalist_own_init == 0) {
        locals.op_own_ptr->g_commalist_own_init = 1;
    }
    enter_proc(544);

  LINE(551);
    {
        {locals.first.tf = true;
        }
        }

  LINE(553);
    {
        CLUREF T_1_1;
        T_1_1.proc = locals.op_own_ptr->ltype_ops->elements.fcn;
        CUR_PROC_VAR = T_1_1;
        locals.err = T_1_1.proc->proc(locals.l, g_commalist_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_0;
        }
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE g_commalist ****/


/**** BEGIN ITERATOR BODIES for g_commalist ****/

errcode g_commalist_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    errcode err;
    errcode ecode2;
g_commalist_OWN_DEFN *op_own_ptr;
    CLUREF first;
    CLUREF x;
    CLUREF e;
    CLUREF l;
    CLUREF eltproc;
    } *locals;
{
    locals->x.num = iv_1.num;
    enter_iter_body_proc(554);

  FB_LINE(554);
    {
    CLUREF T_1_1;
    T_1_1.num = locals->first.num ^ 1;
    if (T_1_1.num == true) {

  FB_LINE(555);
        {
        locals->err = g_envOPputs(locals->e, STR__054_040);
        if (locals->err != ERR_ok) goto ex_0;
        }
        }
    else {

  FB_LINE(556);
        {
        locals->first.tf = false;
        }
        }}/* end if */

  FB_LINE(558);
    {
    CUR_PROC_VAR = locals->eltproc;
    locals->err = locals->eltproc.proc->proc(locals->e, locals->x);
    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 g_commalist_IB_1 */

/**** END ITERATOR BODIES for g_commalist ****/



typedef struct {
int count;
    char *elements_name;
} g_next_commalist_of_ltype_REQS;

g_next_commalist_of_ltype_REQS g_next_commalist_of_ltype_reqs_actual = {1,
    "elements"};

struct REQS * g_next_commalist_of_ltype_reqs = (struct REQS *)&g_next_commalist_of_ltype_reqs_actual;

typedef struct {
    int count;
    OWNPTR type_owns;
    OWNPTR op_owns;
    struct OP_ENTRY elements;
} g_next_commalist_of_ltype_OPS;

typedef struct {
int count;
} g_next_commalist_of_elt_REQS;

g_next_commalist_of_elt_REQS g_next_commalist_of_elt_reqs_actual = {0};

struct REQS * g_next_commalist_of_elt_reqs = (struct REQS *)&g_next_commalist_of_elt_reqs_actual;


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

extern errcode g_next_commalist_IB_1();

typedef struct {
    int g_next_commalist_own_init;
    g_next_commalist_of_ltype_OPS *ltype_ops;
    g_next_commalist_of_elt_OPS *elt_ops;
    } g_next_commalist_OWN_DEFN;
OWN_req g_next_commalist_ownreqs = {sizeof(g_next_commalist_OWN_DEFN), 1};


/**** BEGIN PROCEDURE g_next_commalist ****/

errcode g_next_commalist(e, l, eltproc, cont)
CLUREF e;
CLUREF l;
CLUREF eltproc;
CLUREF cont;
    {
    struct {
        errcode err;
        errcode ecode2;
        g_next_commalist_OWN_DEFN *op_own_ptr;
        CLUREF x;
        CLUREF e;
        CLUREF l;
        CLUREF eltproc;
        CLUREF cont;
        } locals;
    locals.e = e;
    locals.l = l;
    locals.eltproc = eltproc;
    locals.cont = cont;
    locals.op_own_ptr = (g_next_commalist_OWN_DEFN*) CUR_PROC_VAR.proc->op_owns;
        if (locals.op_own_ptr->g_next_commalist_own_init == 0) {
        stringOPcons(", ", CLU_1, CLU_2, &STR__054_040);
        }
        if (locals.op_own_ptr->g_next_commalist_own_init == 0) {
        locals.op_own_ptr->g_next_commalist_own_init = 1;
    }
    enter_proc(562);

  LINE(570);
    {
        CLUREF T_1_1;
        T_1_1.proc = locals.op_own_ptr->ltype_ops->elements.fcn;
        CUR_PROC_VAR = T_1_1;
        locals.err = T_1_1.proc->proc(locals.l, g_next_commalist_IB_1, &locals, &locals.ecode2);
        if (locals.err == ERR_iterbodyreturn) {
        signal(ERR_ok);}
        if (locals.err == ERR_iterbodysignal) {signal(locals.ecode2);}
        if (locals.err == ERR_break) locals.err = ERR_ok;
        if (locals.err == ERR_iterbodyexit) locals.err = locals.ecode2;
        if (locals.err != ERR_ok) goto ex_0;
        }
    goto end_0;
    ex_0:
        {
            if (locals.err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(locals.err);
            {signal(ERR_failure);}
        }
    end_0: {signal(ERR_ok);}
    }

/**** END PROCEDURE g_next_commalist ****/


/**** BEGIN ITERATOR BODIES for g_next_commalist ****/

errcode g_next_commalist_IB_1(iv_1, locals, iecode)
errcode *iecode;
CLUREF iv_1;
struct {
    errcode err;
    errcode ecode2;
g_next_commalist_OWN_DEFN *op_own_ptr;
    CLUREF x;
    CLUREF e;
    CLUREF l;
    CLUREF eltproc;
    CLUREF cont;
    } *locals;
{
    locals->x.num = iv_1.num;
    enter_iter_body_proc(571);

  FB_LINE(571);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = (locals->cont.num == 0)? true : false;
    T_1_2.num = T_1_1.num ^ 1;
    if (T_1_2.num == true) {

  FB_LINE(572);
        {
        locals->err = g_envOPputs(locals->e, STR__054_040);
        if (locals->err != ERR_ok) goto ex_0;
        }
        }
    else {

  FB_LINE(573);
        {
        locals->cont.num = 1;
        }
        }}/* end if */

  FB_LINE(575);
    {
    CUR_PROC_VAR = locals->eltproc;
    locals->err = locals->eltproc.proc->proc(locals->e, locals->x);
    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 g_next_commalist_IB_1 */

/**** END ITERATOR BODIES for g_next_commalist ****/


CLUREF STR_true;
CLUREF STR_false;
static int bool_unparse_own_init = 0;

/**** BEGIN PROCEDURE bool_unparse ****/

errcode bool_unparse(b, ret_1)
CLUREF b;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
        if (bool_unparse_own_init == 0) {
        stringOPcons("true", CLU_1, CLU_4, &STR_true);
        stringOPcons("false", CLU_1, CLU_5, &STR_false);
        bool_unparse_own_init = 1;
    }
    enter_proc(579);

  LINE(580);
    {
    if (b.num == true) {
        {
        {
        ret_1->str = STR_true.str;
        }
        {signal (ERR_ok);}}
        }
    else {

  LINE(581);
        {
        {
        ret_1->str = STR_false.str;
        }
        {signal (ERR_ok);}}
        }}/* end if */
    goto end_0;
    ex_0:
        {
            if (err == ERR_failure) {signal(ERR_failure);}
            elist[0] = _pclu_erstr(err);
            {signal(ERR_failure);}
        }
    end_0: elist[0].str = no_return_values_STRING;
        {signal(ERR_failure);}
    }

/**** END PROCEDURE bool_unparse ****/