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

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


extern errcode exprOPget_abs();
extern errcode idnOPget_kind();
extern errcode e_expr1();

/**** BEGIN PROCEDURE e_expr ****/

errcode e_expr(e, x, ret_1)
CLUREF e;
CLUREF x;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF i;
    enter_proc(6);

  LINE(7);
    {
    CLUREF T_1_1;
    err = exprOPget_abs(x, &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;
        i.num = T_1_2.num;

  LINE(9);
            {
            CLUREF T_2_1;
            err = idnOPget_kind(i, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            switch (T_2_1.cell->tag) {
            case 6: 
            case 10: 
            case 5: 
                 {

  LINE(11);
                    {
                    {
                    ret_1->num = x.num;
                    }
                    {signal (ERR_ok);}}
                    break;
                    }
            default: {
            }
            }
            }
            break;
            }
    default: {
    }
    }
    }

  LINE(16);
    {
    {
    CLUREF T_1_1;
    err = e_expr1(e, x, &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 e_expr ****/


extern errcode oneofOPis_9();
extern errcode typespecOPget_abs();
extern errcode exprOPget_typespec();
extern errcode e_idn();
extern errcode e_condop();
extern errcode e_invoke();
extern errcode e_arraycons();
extern errcode e_selectcons();
extern errcode c_envOPerr1();
extern errcode c_envOPget_bad_expr();
CLUREF STR_cand;
CLUREF STR_cor;
CLUREF STR_UP_040expression_040not_040a_040legal_040constant;
CLUREF STR_DOWN_040expression_040not_040a_040legal_040constant;
CLUREF STR_ANY_040expression_040not_040a_040legal_040constant;
static int e_expr1_own_init = 0;

/**** BEGIN PROCEDURE e_expr1 ****/

errcode e_expr1(e, x, ret_1)
CLUREF e;
CLUREF x;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF xa;
        if (e_expr1_own_init == 0) {
        stringOPcons("cand", CLU_1, CLU_4, &STR_cand);
        stringOPcons("cor", CLU_1, CLU_3, &STR_cor);
        stringOPcons("UP expression not a legal constant", CLU_1, CLU_34, &STR_UP_040expression_040not_040a_040legal_040constant);
        stringOPcons("DOWN expression not a legal constant", CLU_1, CLU_36, &STR_DOWN_040expression_040not_040a_040legal_040constant);
        stringOPcons("ANY expression not a legal constant", CLU_1, CLU_35, &STR_ANY_040expression_040not_040a_040legal_040constant);
        e_expr1_own_init = 1;
    }
    enter_proc(19);

  LINE(20);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    err = exprOPget_typespec(x, &T_1_1);
    if (err != ERR_ok) goto ex_0;
    err = typespecOPget_abs(T_1_1, &T_1_2);
    if (err != ERR_ok) goto ex_0;
    if (T_1_2.cell->tag == 9) T_1_3.num = true; else T_1_3.num = false;
    if (T_1_3.num == true) {

  LINE(21);
        {
        {
        ret_1->num = x.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(22);
    {
    CLUREF T_1_1;
    err = exprOPget_abs(x, &T_1_1);
    if (err != ERR_ok) goto ex_0;
    switch (T_1_1.cell->tag) {
    case 19: 
    case 5: 
    case 15: 
    case 21: 
    case 7: 
    case 24: 
    case 25: 
    case 3: 
    case 20: 
    case 11: 
         {

  LINE(24);
            {
            {
            ret_1->num = x.num;
            }
            {signal (ERR_ok);}}
            break;
            }
    case 13: 
         {CLUREF T_1_2;
        T_1_2.num = T_1_1.cell->value;
        xa.num = T_1_2.num;

  LINE(26);
            {
            {
            CLUREF T_2_1;
            err = e_idn(e, x, xa, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            ret_1->num = T_2_1.num;
            }
            {signal (ERR_ok);}}
            break;
            }
    case 6: 
         {CLUREF T_1_3;
        T_1_3.num = T_1_1.cell->value;
        xa.num = T_1_3.num;

  LINE(28);
            {
            {
            CLUREF T_2_1;
            err = e_condop(e, xa, STR_cand, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            ret_1->num = T_2_1.num;
            }
            {signal (ERR_ok);}}
            break;
            }
    case 8: 
         {CLUREF T_1_4;
        T_1_4.num = T_1_1.cell->value;
        xa.num = T_1_4.num;

  LINE(30);
            {
            {
            CLUREF T_2_1;
            err = e_condop(e, xa, STR_cor, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            ret_1->num = T_2_1.num;
            }
            {signal (ERR_ok);}}
            break;
            }
    case 16: 
         {CLUREF T_1_5;
        T_1_5.num = T_1_1.cell->value;
        xa.num = T_1_5.num;

  LINE(32);
            {
            {
            CLUREF T_2_1;
            err = e_invoke(e, x, xa, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            ret_1->num = T_2_1.num;
            }
            {signal (ERR_ok);}}
            break;
            }
    case 1: 
         {CLUREF T_1_6;
        T_1_6.num = T_1_1.cell->value;
        xa.num = T_1_6.num;

  LINE(34);
            {
            {
            CLUREF T_2_1;
            err = e_arraycons(e, x, xa, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            ret_1->num = T_2_1.num;
            }
            {signal (ERR_ok);}}
            break;
            }
    case 23: 
         {CLUREF T_1_7;
        T_1_7.num = T_1_1.cell->value;
        xa.num = T_1_7.num;

  LINE(36);
            {
            {
            CLUREF T_2_1;
            err = e_selectcons(e, x, xa, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            ret_1->num = T_2_1.num;
            }
            {signal (ERR_ok);}}
            break;
            }
    case 27: 
         {

  LINE(38);
            {
            err = c_envOPerr1(e, STR_UP_040expression_040not_040a_040legal_040constant);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 9: 
         {

  LINE(40);
            {
            err = c_envOPerr1(e, STR_DOWN_040expression_040not_040a_040legal_040constant);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 2: 
         {

  LINE(42);
            {
            err = c_envOPerr1(e, STR_ANY_040expression_040not_040a_040legal_040constant);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 4: 
         {
            break;
            }
    default: {
    }
    }
    }

  LINE(46);
    {
    {
    CLUREF T_1_1;
    err = c_envOPget_bad_expr(e, &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 e_expr1 ****/


extern errcode c_envOPerr();
extern errcode idnOPget_str();
CLUREF STR_use_040of_040parameter_040_047;
CLUREF STR__047_040as_040argument_040in_040constant_040expression;
CLUREF STR_use_040of_040variable_040_047;
CLUREF STR__047_040as_040constant;
static int e_idn_own_init = 0;

/**** BEGIN PROCEDURE e_idn ****/

errcode e_idn(e, x, i, ret_1)
CLUREF e;
CLUREF x;
CLUREF i;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
        if (e_idn_own_init == 0) {
        stringOPcons("use of parameter \'", CLU_1, CLU_18, &STR_use_040of_040parameter_040_047);
        stringOPcons("\' as argument in constant expression", CLU_1, CLU_36, &STR__047_040as_040argument_040in_040constant_040expression);
        stringOPcons("use of variable \'", CLU_1, CLU_17, &STR_use_040of_040variable_040_047);
        stringOPcons("\' as constant", CLU_1, CLU_13, &STR__047_040as_040constant);
        e_idn_own_init = 1;
    }
    enter_proc(49);

  LINE(50);
    {
    CLUREF T_1_1;
    err = idnOPget_kind(i, &T_1_1);
    if (err != ERR_ok) goto ex_0;
    switch (T_1_1.cell->tag) {
    case 6: 
    case 10: 
    case 5: 
         {

  LINE(52);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            sequenceOPnew2(CLU_3, &T_2_1);
            T_2_1.vec->data[0] = STR_use_040of_040parameter_040_047.num;
            err = idnOPget_str(i, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            T_2_1.vec->data[1] = T_2_2.num;
            T_2_1.vec->data[2] = STR__047_040as_040argument_040in_040constant_040expression.num;
            err = c_envOPerr(e, T_2_1);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    case 9: 
    case 4: 
         {

  LINE(55);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            sequenceOPnew2(CLU_3, &T_2_1);
            T_2_1.vec->data[0] = STR_use_040of_040variable_040_047.num;
            err = idnOPget_str(i, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            T_2_1.vec->data[1] = T_2_2.num;
            T_2_1.vec->data[2] = STR__047_040as_040constant.num;
            err = c_envOPerr(e, T_2_1);
            if (err != ERR_ok) goto ex_0;
            }
            break;
            }
    default: {
    }
    }
    }

  LINE(58);
    {
    {
    CLUREF T_1_1;
    err = c_envOPget_bad_expr(e, &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 e_idn ****/


extern errcode recordOPget_3();
extern errcode boolOPnot();
extern errcode duOPequal();
extern errcode recordOPget_1();
extern errcode c_envOPget_seq_();
extern errcode sequenceOPindexes();
extern errcode sequenceOPfetch();
extern errcode exprOPequal();
extern errcode sequenceOPreplace();
extern errcode oneofOPmake_1();
extern errcode exprOPcreate();
CLUREF STR_constructor_040not_040a_040legal_040constant;
static int e_arraycons_own_init = 0;

/**** BEGIN PROCEDURE e_arraycons ****/

errcode e_arraycons(e, x, cons, ret_1)
CLUREF e;
CLUREF x;
CLUREF cons;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF ta;
    CLUREF elts;
    CLUREF same;
    CLUREF i;
    CLUREF elt;
    CLUREF nelt;
        if (e_arraycons_own_init == 0) {
        stringOPcons("constructor not a legal constant", CLU_1, CLU_32, &STR_constructor_040not_040a_040legal_040constant);
        e_arraycons_own_init = 1;
    }
    enter_proc(61);

  LINE(62);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = cons.vec->data[2];
    err = typespecOPget_abs(T_1_1, &T_1_2);
    if (err != ERR_ok) goto ex_0;
    switch (T_1_2.cell->tag) {
    case 3: 
         {CLUREF T_1_3;
        T_1_3.num = T_1_2.cell->value;
        ta.num = T_1_3.num;

  LINE(64);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
            T_2_1.num = ta.vec->data[0];
            err = c_envOPget_seq_(e, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = duOPequal(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(65);
                {
                err = c_envOPerr1(e, STR_constructor_040not_040a_040legal_040constant);
                if (err != ERR_ok) goto ex_0;
                }

  LINE(66);
                {
                {
                CLUREF T_3_1;
                err = c_envOPget_bad_expr(e, &T_3_1);
                if (err != ERR_ok) goto ex_0;
                ret_1->num = T_3_1.num;
                }
                {signal (ERR_ok);}}
                }
                }/* end if */
            break;
            }
    case 9: 
         {

  LINE(69);
            {
            {
            CLUREF T_2_1;
            err = c_envOPget_bad_expr(e, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            ret_1->num = T_2_1.num;
            }
            {signal (ERR_ok);}}
            break;
            }
    default: {

  LINE(71);
        {
        err = c_envOPerr1(e, STR_constructor_040not_040a_040legal_040constant);
        if (err != ERR_ok) goto ex_0;
        }

  LINE(72);
        {
        {
        CLUREF T_2_1;
        err = c_envOPget_bad_expr(e, &T_2_1);
        if (err != ERR_ok) goto ex_0;
        ret_1->num = T_2_1.num;
        }
        {signal (ERR_ok);}}
    }
    }
    }

  LINE(74);
    {
        {CLUREF T_1_1;
        T_1_1.num = cons.vec->data[0];
        elts.num = T_1_1.num;
        }
        }

  LINE(75);
    {
        {same.tf = true;
        }
        }

  LINE(76);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
        T_1_2.num = elts.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(77);
            {
                {CLUREF T_2_1;
                if (i.num < 1 || i.num > elts.vec->size ) {
                    err = ERR_bounds;
                    goto ex_0;}
                T_2_1.num = elts.vec->data[i.num - 1];
                elt.num = T_2_1.num;
                }
                }

  LINE(78);
            {
                {CLUREF T_2_1;
                err = e_expr1(e, elt, &T_2_1);
                if (err != ERR_ok) goto ex_0;
                nelt.num = T_2_1.num;
                }
                }

  LINE(79);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            err = exprOPequal(nelt, elt, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            T_2_2.num = T_2_1.num ^ 1;
            if (T_2_2.num == true) {

  LINE(80);
                {
                CLUREF T_3_1;
                err = sequenceOPreplace(elts, i, nelt, &T_3_1);
                if (err != ERR_ok) goto ex_0;
                elts.num = T_3_1.num;
                }

  LINE(81);
                {
                same.tf = false;
                }
                }
                }/* end if */
        }
    }
    end_inline_for_1:;

  LINE(84);
    {
    if (same.num == true) {

  LINE(85);
        {
        {
        ret_1->num = x.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(86);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    RecordAlloc(3, T_1_1);
    T_1_2.num = cons.vec->data[2];
    T_1_1.vec->data[2]  = T_1_2.num;
    CellAlloc(1, nil, T_1_3);
    T_1_1.vec->data[1]  = T_1_3.num;
    T_1_1.vec->data[0]  = elts.num;
    cons.num = T_1_1.num;
    }

  LINE(89);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CellAlloc(1, cons.num, T_1_1);
    T_1_2.num = cons.vec->data[2];
    err = exprOPcreate(T_1_1, T_1_2, &T_1_3);
    if (err != ERR_ok) goto ex_0;
    ret_1->num = T_1_3.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 e_arraycons ****/


extern errcode recordOPget_2();
extern errcode c_envOPget_struct_();
extern errcode oneofOPmake_23();
static int e_selectcons_own_init = 0;

/**** BEGIN PROCEDURE e_selectcons ****/

errcode e_selectcons(e, x, cons, ret_1)
CLUREF e;
CLUREF x;
CLUREF cons;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF ta;
    CLUREF fields;
    CLUREF same;
    CLUREF i;
    CLUREF f;
    CLUREF nval;
        if (e_selectcons_own_init == 0) {
        stringOPcons("constructor not a legal constant", CLU_1, CLU_32, &STR_constructor_040not_040a_040legal_040constant);
        e_selectcons_own_init = 1;
    }
    enter_proc(92);

  LINE(93);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = cons.vec->data[1];
    err = typespecOPget_abs(T_1_1, &T_1_2);
    if (err != ERR_ok) goto ex_0;
    switch (T_1_2.cell->tag) {
    case 7: 
         {CLUREF T_1_3;
        T_1_3.num = T_1_2.cell->value;
        ta.num = T_1_3.num;

  LINE(95);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            CLUREF T_2_4;
            T_2_1.num = ta.vec->data[0];
            err = c_envOPget_struct_(e, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            err = duOPequal(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(96);
                {
                err = c_envOPerr1(e, STR_constructor_040not_040a_040legal_040constant);
                if (err != ERR_ok) goto ex_0;
                }

  LINE(97);
                {
                {
                CLUREF T_3_1;
                err = c_envOPget_bad_expr(e, &T_3_1);
                if (err != ERR_ok) goto ex_0;
                ret_1->num = T_3_1.num;
                }
                {signal (ERR_ok);}}
                }
                }/* end if */
            break;
            }
    case 9: 
         {

  LINE(100);
            {
            {
            CLUREF T_2_1;
            err = c_envOPget_bad_expr(e, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            ret_1->num = T_2_1.num;
            }
            {signal (ERR_ok);}}
            break;
            }
    default: {

  LINE(102);
        {
        err = c_envOPerr1(e, STR_constructor_040not_040a_040legal_040constant);
        if (err != ERR_ok) goto ex_0;
        }

  LINE(103);
        {
        {
        CLUREF T_2_1;
        err = c_envOPget_bad_expr(e, &T_2_1);
        if (err != ERR_ok) goto ex_0;
        ret_1->num = T_2_1.num;
        }
        {signal (ERR_ok);}}
    }
    }
    }

  LINE(105);
    {
        {CLUREF T_1_1;
        T_1_1.num = cons.vec->data[0];
        fields.num = T_1_1.num;
        }
        }

  LINE(106);
    {
        {same.tf = true;
        }
        }

  LINE(107);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
        T_1_2.num = fields.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(108);
            {
                {CLUREF T_2_1;
                if (i.num < 1 || i.num > fields.vec->size ) {
                    err = ERR_bounds;
                    goto ex_0;}
                T_2_1.num = fields.vec->data[i.num - 1];
                f.num = T_2_1.num;
                }
                }

  LINE(109);
            {
                {CLUREF T_2_1;
                CLUREF T_2_2;
                T_2_1.num = f.vec->data[2];
                err = e_expr1(e, T_2_1, &T_2_2);
                if (err != ERR_ok) goto ex_0;
                nval.num = T_2_2.num;
                }
                }

  LINE(110);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            CLUREF T_2_3;
            T_2_1.num = f.vec->data[2];
            err = exprOPequal(nval, T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            T_2_3.num = T_2_2.num ^ 1;
            if (T_2_3.num == true) {

  LINE(111);
                {
                CLUREF T_3_1;
                CLUREF T_3_2;
                CLUREF T_3_3;
                RecordAlloc(3, T_3_1);
                T_3_2.num = f.vec->data[1];
                T_3_1.vec->data[1]  = T_3_2.num;
                T_3_1.vec->data[2]  = nval.num;
                T_3_3.num = f.vec->data[0];
                T_3_1.vec->data[0]  = T_3_3.num;
                f.num = T_3_1.num;
                }

  LINE(114);
                {
                CLUREF T_3_1;
                err = sequenceOPreplace(fields, i, f, &T_3_1);
                if (err != ERR_ok) goto ex_0;
                fields.num = T_3_1.num;
                }

  LINE(115);
                {
                same.tf = false;
                }
                }
                }/* end if */
        }
    }
    end_inline_for_1:;

  LINE(118);
    {
    if (same.num == true) {

  LINE(119);
        {
        {
        ret_1->num = x.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(120);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    RecordAlloc(2, T_1_1);
    T_1_2.num = cons.vec->data[1];
    T_1_1.vec->data[1]  = T_1_2.num;
    T_1_1.vec->data[0]  = fields.num;
    cons.num = T_1_1.num;
    }

  LINE(122);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CellAlloc(23, cons.num, T_1_1);
    T_1_2.num = cons.vec->data[1];
    err = exprOPcreate(T_1_1, T_1_2, &T_1_3);
    if (err != ERR_ok) goto ex_0;
    ret_1->num = T_1_3.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 e_selectcons ****/


extern errcode e_exprlist();
extern errcode stringOPequal();
extern errcode typespecOPequal();
extern errcode c_envOPget_null_type();
extern errcode e_nullop();
extern errcode c_envOPget_bool_type();
extern errcode e_boolop();
extern errcode c_envOPget_int_type();
extern errcode e_intop();
extern errcode c_envOPget_real_type();
extern errcode e_realop();
extern errcode c_envOPget_char_type();
extern errcode e_charop();
extern errcode c_envOPget_str_type();
extern errcode e_strop();
extern errcode e_seqop();
extern errcode c_envOPget_oneof_();
extern errcode e_oneofop();
extern errcode e_structop();
extern errcode c_envOPget_proc_();
extern errcode c_envOPget_iter_();
extern errcode e_applyop();
extern errcode get_inv_print();
CLUREF STR_encode;
CLUREF STR_decode;
CLUREF STR_print;
CLUREF STR_invocation_040of_040_047;
CLUREF STR__047_040evaluates_040to_040_047;
CLUREF STR__047_040exception;
CLUREF STR__047_040illegal_040in_040constant;
static int e_invoke_own_init = 0;

/**** BEGIN PROCEDURE e_invoke ****/

errcode e_invoke(e, x, inv, ret_1)
CLUREF e;
CLUREF x;
CLUREF inv;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF p;
    CLUREF args;
    CLUREF pa;
    CLUREF op;
    CLUREF t;
    CLUREF ta;
    CLUREF err_UNIQ;
        if (e_invoke_own_init == 0) {
        stringOPcons("encode", CLU_1, CLU_6, &STR_encode);
        stringOPcons("decode", CLU_1, CLU_6, &STR_decode);
        stringOPcons("print", CLU_1, CLU_5, &STR_print);
        stringOPcons("invocation of \'", CLU_1, CLU_15, &STR_invocation_040of_040_047);
        stringOPcons("\' evaluates to \'", CLU_1, CLU_16, &STR__047_040evaluates_040to_040_047);
        stringOPcons("\' exception", CLU_1, CLU_11, &STR__047_040exception);
        stringOPcons("\' illegal in constant", CLU_1, CLU_21, &STR__047_040illegal_040in_040constant);
        e_invoke_own_init = 1;
    }
    enter_proc(125);

  LINE(126);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        T_1_1.num = inv.vec->data[0];
        err = e_expr1(e, T_1_1, &T_1_2);
        if (err != ERR_ok) goto ex_0;
        p.num = T_1_2.num;
        }
        }

  LINE(127);
    {
        {CLUREF T_1_1;
        T_1_1.num = inv.vec->data[1];
        args.num = T_1_1.num;
        }
        }

  LINE(128);
    {
    CLUREF T_1_1;
    err = e_exprlist(e, args, &T_1_1);
    if (err != ERR_ok) goto ex_0;
    args.num = T_1_1.num;
    }

  LINE(129);
    {
    CLUREF T_2_1;
    err = exprOPget_abs(p, &T_2_1);
    if (err != ERR_ok) goto ex_1;
    switch (T_2_1.cell->tag) {
    case 20: 
         {CLUREF T_2_2;
        T_2_2.num = T_2_1.cell->value;
        pa.num = T_2_2.num;

  LINE(131);
            {
                {CLUREF T_3_1;
                T_3_1.num = pa.vec->data[0];
                op.num = T_3_1.num;
                }
                }

  LINE(132);
            {
                {CLUREF T_3_1;
                T_3_1.num = pa.vec->data[2];
                t.num = T_3_1.num;
                }
                }

  LINE(133);
            {
            CLUREF T_3_1;
            err = typespecOPget_abs(t, &T_3_1);
            if (err != ERR_ok) goto ex_1;
            switch (T_3_1.cell->tag) {
            case 3: 
                 {CLUREF T_3_2;
                T_3_2.num = T_3_1.cell->value;
                ta.num = T_3_2.num;

  LINE(135);
                    {
                    CLUREF T_4_1;
                    CLUREF T_4_2;
                    CLUREF T_4_3;
                    CLUREF T_4_4;
                    CLUREF T_4_5;
                    T_4_3.num = ((op.str->size != STR_encode.str->size)? false :
                        !(bcmp(op.str->data, STR_encode.str->data, op.str->size)));
                    T_4_2.num = T_4_3.num;
                    if (!T_4_3.num) {
                        T_4_4.num = ((op.str->size != STR_decode.str->size)? false :
                            !(bcmp(op.str->data, STR_decode.str->data, op.str->size)));
                        T_4_2.num = T_4_4.num;
                    }
                    T_4_1.num = T_4_2.num;
                    if (!T_4_2.num) {
                        T_4_5.num = ((op.str->size != STR_print.str->size)? false :
                            !(bcmp(op.str->data, STR_print.str->data, op.str->size)));
                        T_4_1.num = T_4_5.num;
                    }
                    if (T_4_1.num == true) {

  LINE(136);
                        {
                            err = ERR_illegal;
                            goto ex_1;
                            }
                        }
                    else {
                    CLUREF T_4_6;
                    CLUREF T_4_7;
                    err = c_envOPget_null_type(e, &T_4_6);
                    if (err != ERR_ok) goto ex_1;
                    err = typespecOPequal(t, T_4_6, &T_4_7);
                    if (err != ERR_ok) goto ex_1;
                    if (T_4_7.num == true) {

  LINE(138);
                        {
                        {
                        CLUREF T_5_1;
                        err = e_nullop(e, op, args, &T_5_1);
                        if (err != ERR_ok) goto ex_1;
                        ret_1->num = T_5_1.num;
                        }
                        {signal (ERR_ok);}}
                        }
                    else {
                    CLUREF T_4_8;
                    CLUREF T_4_9;
                    err = c_envOPget_bool_type(e, &T_4_8);
                    if (err != ERR_ok) goto ex_1;
                    err = typespecOPequal(t, T_4_8, &T_4_9);
                    if (err != ERR_ok) goto ex_1;
                    if (T_4_9.num == true) {

  LINE(140);
                        {
                        {
                        CLUREF T_5_1;
                        err = e_boolop(e, op, args, &T_5_1);
                        if (err != ERR_ok) goto ex_1;
                        ret_1->num = T_5_1.num;
                        }
                        {signal (ERR_ok);}}
                        }
                    else {
                    CLUREF T_4_10;
                    CLUREF T_4_11;
                    err = c_envOPget_int_type(e, &T_4_10);
                    if (err != ERR_ok) goto ex_1;
                    err = typespecOPequal(t, T_4_10, &T_4_11);
                    if (err != ERR_ok) goto ex_1;
                    if (T_4_11.num == true) {

  LINE(142);
                        {
                        {
                        CLUREF T_5_1;
                        err = e_intop(e, op, args, &T_5_1);
                        if (err != ERR_ok) goto ex_1;
                        ret_1->num = T_5_1.num;
                        }
                        {signal (ERR_ok);}}
                        }
                    else {
                    CLUREF T_4_12;
                    CLUREF T_4_13;
                    err = c_envOPget_real_type(e, &T_4_12);
                    if (err != ERR_ok) goto ex_1;
                    err = typespecOPequal(t, T_4_12, &T_4_13);
                    if (err != ERR_ok) goto ex_1;
                    if (T_4_13.num == true) {

  LINE(144);
                        {
                        {
                        CLUREF T_5_1;
                        err = e_realop(e, op, args, &T_5_1);
                        if (err != ERR_ok) goto ex_1;
                        ret_1->num = T_5_1.num;
                        }
                        {signal (ERR_ok);}}
                        }
                    else {
                    CLUREF T_4_14;
                    CLUREF T_4_15;
                    err = c_envOPget_char_type(e, &T_4_14);
                    if (err != ERR_ok) goto ex_1;
                    err = typespecOPequal(t, T_4_14, &T_4_15);
                    if (err != ERR_ok) goto ex_1;
                    if (T_4_15.num == true) {

  LINE(146);
                        {
                        {
                        CLUREF T_5_1;
                        err = e_charop(e, op, args, &T_5_1);
                        if (err != ERR_ok) goto ex_1;
                        ret_1->num = T_5_1.num;
                        }
                        {signal (ERR_ok);}}
                        }
                    else {
                    CLUREF T_4_16;
                    CLUREF T_4_17;
                    err = c_envOPget_str_type(e, &T_4_16);
                    if (err != ERR_ok) goto ex_1;
                    err = typespecOPequal(t, T_4_16, &T_4_17);
                    if (err != ERR_ok) goto ex_1;
                    if (T_4_17.num == true) {

  LINE(148);
                        {
                        {
                        CLUREF T_5_1;
                        err = e_strop(e, op, args, &T_5_1);
                        if (err != ERR_ok) goto ex_1;
                        ret_1->num = T_5_1.num;
                        }
                        {signal (ERR_ok);}}
                        }
                    else {
                    CLUREF T_4_18;
                    CLUREF T_4_19;
                    CLUREF T_4_20;
                    T_4_18.num = ta.vec->data[0];
                    err = c_envOPget_seq_(e, &T_4_19);
                    if (err != ERR_ok) goto ex_1;
                    err = duOPequal(T_4_18, T_4_19, &T_4_20);
                    if (err != ERR_ok) goto ex_1;
                    if (T_4_20.num == true) {

  LINE(150);
                        {
                        {
                        CLUREF T_5_1;
                        err = e_seqop(e, x, pa, args, &T_5_1);
                        if (err != ERR_ok) goto ex_1;
                        ret_1->num = T_5_1.num;
                        }
                        {signal (ERR_ok);}}
                        }
                        }}}}}}}}/* end if */
                    break;
                    }
            case 7: 
                 {CLUREF T_3_3;
                T_3_3.num = T_3_1.cell->value;
                ta.num = T_3_3.num;

  LINE(152);
                    {
                    CLUREF T_4_1;
                    CLUREF T_4_2;
                    CLUREF T_4_3;
                    T_4_1.num = ta.vec->data[0];
                    err = c_envOPget_oneof_(e, &T_4_2);
                    if (err != ERR_ok) goto ex_1;
                    err = duOPequal(T_4_1, T_4_2, &T_4_3);
                    if (err != ERR_ok) goto ex_1;
                    if (T_4_3.num == true) {

  LINE(153);
                        {
                        {
                        CLUREF T_5_1;
                        err = e_oneofop(e, x, pa, args, &T_5_1);
                        if (err != ERR_ok) goto ex_1;
                        ret_1->num = T_5_1.num;
                        }
                        {signal (ERR_ok);}}
                        }
                    else {
                    CLUREF T_4_4;
                    CLUREF T_4_5;
                    CLUREF T_4_6;
                    T_4_4.num = ta.vec->data[0];
                    err = c_envOPget_struct_(e, &T_4_5);
                    if (err != ERR_ok) goto ex_1;
                    err = duOPequal(T_4_4, T_4_5, &T_4_6);
                    if (err != ERR_ok) goto ex_1;
                    if (T_4_6.num == true) {

  LINE(155);
                        {
                        {
                        CLUREF T_5_1;
                        err = e_structop(e, x, pa, args, &T_5_1);
                        if (err != ERR_ok) goto ex_1;
                        ret_1->num = T_5_1.num;
                        }
                        {signal (ERR_ok);}}
                        }
                        }}/* end if */
                    break;
                    }
            case 2: 
                 {CLUREF T_3_4;
                T_3_4.num = T_3_1.cell->value;
                ta.num = T_3_4.num;

  LINE(157);
                    {
                    CLUREF T_4_1;
                    CLUREF T_4_2;
                    CLUREF T_4_3;
                    CLUREF T_4_4;
                    CLUREF T_4_5;
                    CLUREF T_4_6;
                    CLUREF T_4_7;
                    T_4_2.num = ta.vec->data[1];
                    err = c_envOPget_proc_(e, &T_4_3);
                    if (err != ERR_ok) goto ex_1;
                    err = duOPequal(T_4_2, T_4_3, &T_4_4);
                    if (err != ERR_ok) goto ex_1;
                    T_4_1.num = T_4_4.num;
                    if (!T_4_4.num) {
                        T_4_5.num = ta.vec->data[1];
                        err = c_envOPget_iter_(e, &T_4_6);
                        if (err != ERR_ok) goto ex_1;
                        err = duOPequal(T_4_5, T_4_6, &T_4_7);
                        if (err != ERR_ok) goto ex_1;
                        T_4_1.num = T_4_7.num;
                    }
                    if (T_4_1.num == true) {

  LINE(158);
                        {
                        {
                        CLUREF T_5_1;
                        err = e_applyop(e, op, args, &T_5_1);
                        if (err != ERR_ok) goto ex_1;
                        ret_1->num = T_5_1.num;
                        }
                        {signal (ERR_ok);}}
                        }
                        }/* end if */
                    break;
                    }
            default: {
            }
            }
            }
            break;
            }
    case 3: 
    case 11: 
         {
            break;
            }
    default: {

  LINE(163);
        {
        {
        CLUREF T_3_1;
        err = c_envOPget_bad_expr(e, &T_3_1);
        if (err != ERR_ok) goto ex_1;
        ret_1->num = T_3_1.num;
        }
        {signal (ERR_ok);}}
    }
    }
    }
        goto end_1;
        ex_1:
            if ((err == ERR_illegal)) {
            }
            else if ((err == ERR_bad)) {

  LINE(166);
                {
                {
                CLUREF T_2_1;
                err = c_envOPget_bad_expr(e, &T_2_1);
                if (err != ERR_ok) goto ex_0;
                ret_1->num = T_2_1.num;
                }
                {signal (ERR_ok);}}
            }
            else if ((err == ERR_error)) {
            CLUREF err_UNIQ;
            err_UNIQ.num = elist[0].num;

  LINE(168);
                {
                CLUREF T_2_1;
                CLUREF T_2_2;
                sequenceOPnew2(CLU_5, &T_2_1);
                T_2_1.vec->data[0] = STR_invocation_040of_040_047.num;
                err = get_inv_print(inv, &T_2_2);
                if (err != ERR_ok) goto ex_0;
                T_2_1.vec->data[1] = T_2_2.num;
                T_2_1.vec->data[2] = STR__047_040evaluates_040to_040_047.num;
                T_2_1.vec->data[3] = err_UNIQ.num;
                T_2_1.vec->data[4] = STR__047_040exception.num;
                err = c_envOPerr(e, T_2_1);
                if (err != ERR_ok) goto ex_0;
                }

  LINE(172);
                {
                {
                CLUREF T_2_1;
                err = c_envOPget_bad_expr(e, &T_2_1);
                if (err != ERR_ok) goto ex_0;
                ret_1->num = T_2_1.num;
                }
                {signal (ERR_ok);}}
            }
            else {
                goto ex_0;
            }
        end_1:;

  LINE(174);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    sequenceOPnew2(CLU_3, &T_1_1);
    T_1_1.vec->data[0] = STR_invocation_040of_040_047.num;
    err = get_inv_print(inv, &T_1_2);
    if (err != ERR_ok) goto ex_0;
    T_1_1.vec->data[1] = T_1_2.num;
    T_1_1.vec->data[2] = STR__047_040illegal_040in_040constant.num;
    err = c_envOPerr(e, T_1_1);
    if (err != ERR_ok) goto ex_0;
    }

  LINE(176);
    {
    {
    CLUREF T_1_1;
    err = c_envOPget_bad_expr(e, &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 e_invoke ****/


extern errcode sequenceOPnew();
extern errcode sequenceOPelements();
extern errcode sequenceOPaddh();

/**** BEGIN PROCEDURE e_exprlist ****/

errcode e_exprlist(e, exprs, ret_1)
CLUREF e;
CLUREF exprs;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF nexprs;
    CLUREF x;
    enter_proc(179);

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

  LINE(181);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
        T_1_2.num = exprs.vec->size; 
        T_1_3 = exprs;
        for (T_1_1.num = 1; T_1_1.num <= T_1_2.num; T_1_1.num++) {
            x.num = T_1_3.vec->data[T_1_1.num - 1];

  LINE(182);
            {
            CLUREF T_2_1;
            CLUREF T_2_2;
            err = e_expr1(e, x, &T_2_1);
            if (err != ERR_ok) goto ex_0;
            err = sequenceOPaddh(nexprs, T_2_1, &T_2_2);
            if (err != ERR_ok) goto ex_0;
            nexprs.num = T_2_2.num;
            }
        }
    }
    end_inline_for_1:;

  LINE(184);
    {
    {
    ret_1->num = nexprs.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 e_exprlist ****/


extern errcode oneofOPmake_19();

/**** BEGIN PROCEDURE e_n2e ****/

errcode e_n2e(e, ret_1)
CLUREF e;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    enter_proc(187);

  LINE(188);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CellAlloc(19, nil, T_1_1);
    err = c_envOPget_null_type(e, &T_1_2);
    if (err != ERR_ok) goto ex_0;
    err = exprOPcreate(T_1_1, T_1_2, &T_1_3);
    if (err != ERR_ok) goto ex_0;
    ret_1->num = T_1_3.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 e_n2e ****/


extern errcode oneofOPmake_5();

/**** BEGIN PROCEDURE e_b2e ****/

errcode e_b2e(e, b, ret_1)
CLUREF e;
CLUREF b;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    enter_proc(191);

  LINE(192);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CellAlloc(5, b.num, T_1_1);
    err = c_envOPget_bool_type(e, &T_1_2);
    if (err != ERR_ok) goto ex_0;
    err = exprOPcreate(T_1_1, T_1_2, &T_1_3);
    if (err != ERR_ok) goto ex_0;
    ret_1->num = T_1_3.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 e_b2e ****/


extern errcode oneofOPmake_15();

/**** BEGIN PROCEDURE e_i2e ****/

errcode e_i2e(e, i, ret_1)
CLUREF e;
CLUREF i;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    enter_proc(195);

  LINE(196);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CellAlloc(15, i.num, T_1_1);
    err = c_envOPget_int_type(e, &T_1_2);
    if (err != ERR_ok) goto ex_0;
    err = exprOPcreate(T_1_1, T_1_2, &T_1_3);
    if (err != ERR_ok) goto ex_0;
    ret_1->num = T_1_3.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 e_i2e ****/


extern errcode oneofOPmake_21();

/**** BEGIN PROCEDURE e_r2e ****/

errcode e_r2e(e, r, ret_1)
CLUREF e;
CLUREF r;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    enter_proc(199);

  LINE(200);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CellAlloc(21, r.num, T_1_1);
    err = c_envOPget_real_type(e, &T_1_2);
    if (err != ERR_ok) goto ex_0;
    err = exprOPcreate(T_1_1, T_1_2, &T_1_3);
    if (err != ERR_ok) goto ex_0;
    ret_1->num = T_1_3.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 e_r2e ****/


extern errcode oneofOPmake_7();

/**** BEGIN PROCEDURE e_h2e ****/

errcode e_h2e(e, h, ret_1)
CLUREF e;
CLUREF h;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    enter_proc(203);

  LINE(204);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CellAlloc(7, h.num, T_1_1);
    err = c_envOPget_char_type(e, &T_1_2);
    if (err != ERR_ok) goto ex_0;
    err = exprOPcreate(T_1_1, T_1_2, &T_1_3);
    if (err != ERR_ok) goto ex_0;
    ret_1->num = T_1_3.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 e_h2e ****/


extern errcode oneofOPmake_24();

/**** BEGIN PROCEDURE e_s2e ****/

errcode e_s2e(e, s, ret_1)
CLUREF e;
CLUREF s;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    enter_proc(207);

  LINE(208);
    {
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    CellAlloc(24, s.num, T_1_1);
    err = c_envOPget_str_type(e, &T_1_2);
    if (err != ERR_ok) goto ex_0;
    err = exprOPcreate(T_1_1, T_1_2, &T_1_3);
    if (err != ERR_ok) goto ex_0;
    ret_1->num = T_1_3.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 e_s2e ****/


extern errcode e_e2b();
static int e_condop_own_init = 0;

/**** BEGIN PROCEDURE e_condop ****/

errcode e_condop(e, args, op, ret_1)
CLUREF e;
CLUREF args;
CLUREF op;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF x1;
    CLUREF b;
    CLUREF x2;
        if (e_condop_own_init == 0) {
        stringOPcons("cand", CLU_1, CLU_4, &STR_cand);
        stringOPcons("cor", CLU_1, CLU_3, &STR_cor);
        e_condop_own_init = 1;
    }
    enter_proc(211);

  LINE(212);
    {

  LINE(213);
        {
            {CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = args.vec->data[0];
            err = e_expr1(e, T_3_1, &T_3_2);
            if (err != ERR_ok) goto ex_1;
            x1.num = T_3_2.num;
            }
            }

  LINE(214);
        {
            {CLUREF T_3_1;
            err = e_e2b(x1, &T_3_1);
            if (err != ERR_ok) goto ex_1;
            b.num = T_3_1.num;
            }
            }

  LINE(215);
        {
        CLUREF T_3_1;
        CLUREF T_3_2;
        CLUREF T_3_3;
        CLUREF T_3_4;
        CLUREF T_3_5;
        CLUREF T_3_6;
        T_3_3.num = ((op.str->size != STR_cand.str->size)? false :
            !(bcmp(op.str->data, STR_cand.str->data, op.str->size)));
        T_3_2.num = T_3_3.num;
        if (T_3_3.num) {
            T_3_4.num = b.num ^ 1;
            T_3_2.num = T_3_4.num;
        }
        T_3_1.num = T_3_2.num;
        if (!T_3_2.num) {
            T_3_6.num = ((op.str->size != STR_cor.str->size)? false :
                !(bcmp(op.str->data, STR_cor.str->data, op.str->size)));
            T_3_5.num = T_3_6.num;
            if (T_3_6.num) {
                T_3_5.num = b.num;
            }
            T_3_1.num = T_3_5.num;
        }
        if (T_3_1.num == true) {

  LINE(216);
            {
            {
            ret_1->num = x1.num;
            }
            {signal (ERR_ok);}}
            }
            }/* end if */

  LINE(217);
        {
            {CLUREF T_3_1;
            CLUREF T_3_2;
            T_3_1.num = args.vec->data[1];
            err = e_expr1(e, T_3_1, &T_3_2);
            if (err != ERR_ok) goto ex_1;
            x2.num = T_3_2.num;
            }
            }

  LINE(218);
        {
        CLUREF T_3_1;
        err = e_e2b(x2, &T_3_1);
        if (err != ERR_ok) goto ex_1;
        }

  LINE(219);
        {
        {
        ret_1->num = x2.num;
        }
        {signal (ERR_ok);}}
        }
        goto end_1;
        ex_1:
            if ((err == ERR_bad)) {

  LINE(221);
                {
                {
                CLUREF T_2_1;
                err = c_envOPget_bad_expr(e, &T_2_1);
                if (err != ERR_ok) goto ex_0;
                ret_1->num = T_2_1.num;
                }
                {signal (ERR_ok);}}
            }
            else {
                goto ex_0;
            }
        end_1:;
    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 e_condop ****/


extern errcode intOPequal();
extern errcode sequenceOPsize();
extern errcode sequenceOPbottom();
extern errcode oneofOPis_4();
extern errcode e_b2e();
extern errcode oneofOPsimilar();
extern struct REQS *sequence_of_t_reqs;
extern struct OPS *expr_ops;
extern OWN_req sequence_ownreqs;
extern struct OPS *sequence_ops;
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 *null_ops;
struct OPS  *oneof_none_one_ops;
extern struct OPS *sequence_of_expr_ops;
extern struct OPS *oneof_none_one_ops;
extern struct OPS *typespec_ops;
struct OPS  *record_elts_low_type__ops;
extern struct OPS *du_ops;
struct OPS  *record_gen_parms_ops;
struct OPS  *record_left_right_ops;
struct OPS  *record_index_object_ops;
extern struct OPS *string_ops;
struct OPS  *record_object_sel_ops;
extern struct OPS *bool_ops;
struct OPS  *record_left_neg_op_right_ops;
struct OPS  *record_apply_args_ops;
struct OPS  *record_name_parms_type__ops;
extern struct OPS *idn_ops;
struct OPS  *record_idn_parms_ops;
struct OPS *sequence_of_string_table;
struct OPS *sequence_of_string_ops;
struct OPS *sequence_of_string_ops;
OWNPTR sequence_of_string_owns;
extern struct OPS *int_ops;
extern struct OPS *sequence_of_string_ops;
struct OPS  *record_line_sels_val_ops;
extern struct OPS *record_line_sels_val_ops;
struct OPS *sequence_of_record_line_sels_val_table;
struct OPS *sequence_of_record_line_sels_val_ops;
struct OPS *sequence_of_record_line_sels_val_ops;
OWNPTR sequence_of_record_line_sels_val_owns;
extern struct OPS *sequence_of_record_line_sels_val_ops;
struct OPS  *record_fields_type__ops;
extern struct OPS *record_elts_low_type__ops;
extern struct OPS *record_gen_parms_ops;
extern struct OPS *record_left_right_ops;
extern struct OPS *char_ops;
extern struct OPS *record_index_object_ops;
extern struct OPS *record_object_sel_ops;
extern struct OPS *record_left_neg_op_right_ops;
extern struct OPS *record_apply_args_ops;
extern struct OPS *record_name_parms_type__ops;
extern struct OPS *real_ops;
extern struct OPS *record_idn_parms_ops;
extern struct OPS *record_fields_type__ops;
struct OPS  *oneof_a_cons_any__apply_bad_bool__cand__char__cor__down__fetch_force__get_idn_infix_int__invoke_minus_not_null__op_real__ref_s_cons_str_type__type_of__up__ops;
static int e_applyop_own_init = 0;

/**** BEGIN PROCEDURE e_applyop ****/

errcode e_applyop(e, op, args, ret_1)
CLUREF e;
CLUREF op;
CLUREF args;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF a1;
    CLUREF a2;
        if (e_applyop_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("none", 0, null_ops); 
        add_selector_info("one", 1, expr_ops); 
        find_selector_ops("oneof", 2, &(oneof_none_one_ops));
        add_selector_info("elts", 0, sequence_of_expr_ops); 
        add_selector_info("low", 1, oneof_none_one_ops); 
        add_selector_info("type_", 2, typespec_ops); 
        find_selector_ops("record", 3, &(record_elts_low_type__ops));
        add_selector_info("gen", 0, du_ops); 
        add_selector_info("parms", 1, sequence_of_expr_ops); 
        find_selector_ops("record", 2, &(record_gen_parms_ops));
        add_selector_info("left", 0, expr_ops); 
        add_selector_info("right", 1, expr_ops); 
        find_selector_ops("record", 2, &(record_left_right_ops));
        add_selector_info("index", 0, expr_ops); 
        add_selector_info("object", 1, expr_ops); 
        find_selector_ops("record", 2, &(record_index_object_ops));
        add_selector_info("object", 0, expr_ops); 
        add_selector_info("sel", 1, string_ops); 
        find_selector_ops("record", 2, &(record_object_sel_ops));
        add_selector_info("left", 0, expr_ops); 
        add_selector_info("neg", 1, bool_ops); 
        add_selector_info("op", 2, string_ops); 
        add_selector_info("right", 3, expr_ops); 
        find_selector_ops("record", 4, &(record_left_neg_op_right_ops));
        add_selector_info("apply", 0, expr_ops); 
        add_selector_info("args", 1, sequence_of_expr_ops); 
        find_selector_ops("record", 2, &(record_apply_args_ops));
        add_selector_info("name", 0, string_ops); 
        add_selector_info("parms", 1, sequence_of_expr_ops); 
        add_selector_info("type_", 2, typespec_ops); 
        find_selector_ops("record", 3, &(record_name_parms_type__ops));
        add_selector_info("idn", 0, idn_ops); 
        add_selector_info("parms", 1, sequence_of_expr_ops); 
        find_selector_ops("record", 2, &(record_idn_parms_ops));
        add_parm_info_type(0, string_ops, sequence_of_t_reqs);
        find_type_instance(sequence_ops, 1, &sequence_ownreqs, &(sequence_of_string_ops));
        add_selector_info("line", 0, int_ops); 
        add_selector_info("sels", 1, sequence_of_string_ops); 
        add_selector_info("val", 2, expr_ops); 
        find_selector_ops("record", 3, &(record_line_sels_val_ops));
        add_parm_info_type(0, record_line_sels_val_ops, sequence_of_t_reqs);
        find_type_instance(sequence_ops, 1, &sequence_ownreqs, &(sequence_of_record_line_sels_val_ops));
        add_selector_info("fields", 0, sequence_of_record_line_sels_val_ops); 
        add_selector_info("type_", 1, typespec_ops); 
        find_selector_ops("record", 2, &(record_fields_type__ops));
        add_selector_info("a_cons", 0, record_elts_low_type__ops); 
        add_selector_info("any_", 1, expr_ops); 
        add_selector_info("apply", 2, record_gen_parms_ops); 
        add_selector_info("bad", 3, null_ops); 
        add_selector_info("bool_", 4, bool_ops); 
        add_selector_info("cand_", 5, record_left_right_ops); 
        add_selector_info("char_", 6, char_ops); 
        add_selector_info("cor_", 7, record_left_right_ops); 
        add_selector_info("down_", 8, expr_ops); 
        add_selector_info("fetch", 9, record_index_object_ops); 
        add_selector_info("force_", 10, typespec_ops); 
        add_selector_info("get", 11, record_object_sel_ops); 
        add_selector_info("idn", 12, idn_ops); 
        add_selector_info("infix", 13, record_left_neg_op_right_ops); 
        add_selector_info("int_", 14, int_ops); 
        add_selector_info("invoke", 15, record_apply_args_ops); 
        add_selector_info("minus", 16, expr_ops); 
        add_selector_info("not", 17, expr_ops); 
        add_selector_info("null_", 18, null_ops); 
        add_selector_info("op", 19, record_name_parms_type__ops); 
        add_selector_info("real_", 20, real_ops); 
        add_selector_info("ref", 21, record_idn_parms_ops); 
        add_selector_info("s_cons", 22, record_fields_type__ops); 
        add_selector_info("str", 23, string_ops); 
        add_selector_info("type_", 24, typespec_ops); 
        add_selector_info("type_of_", 25, expr_ops); 
        add_selector_info("up_", 26, expr_ops); 
        find_selector_ops("oneof", 27, &(oneof_a_cons_any__apply_bad_bool__cand__char__cor__down__fetch_force__get_idn_infix_int__invoke_minus_not_null__op_real__ref_s_cons_str_type__type_of__up__ops));
        e_applyop_own_init = 1;
    }
    enter_proc(224);

  LINE(225);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    T_1_1.num = args.vec->size;
    T_1_2.num = (T_1_1.num == 1)? true : false;
    if (T_1_2.num == true) {

  LINE(226);
        {
        {
        CLUREF T_2_1;
        err = sequenceOPbottom(args, &T_2_1);
        if (err != ERR_ok) goto ex_0;
        ret_1->num = T_2_1.num;
        }
        {signal (ERR_ok);}}
        }
        }/* end if */

  LINE(227);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        if (1 < 1 || 1 > args.vec->size ) {
            err = ERR_bounds;
            goto ex_0;}
        T_1_1.num = args.vec->data[1 - 1];
        err = exprOPget_abs(T_1_1, &T_1_2);
        if (err != ERR_ok) goto ex_0;
        a1.num = T_1_2.num;
        }
        }

  LINE(228);
    {
        {CLUREF T_1_1;
        CLUREF T_1_2;
        if (2 < 1 || 2 > args.vec->size ) {
            err = ERR_bounds;
            goto ex_0;}
        T_1_1.num = args.vec->data[2 - 1];
        err = exprOPget_abs(T_1_1, &T_1_2);
        if (err != ERR_ok) goto ex_0;
        a2.num = T_1_2.num;
        }
        }

  LINE(229);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    if (a1.cell->tag == 4) T_1_2.num = true; else T_1_2.num = false;
    T_1_1.num = T_1_2.num;
    if (!T_1_2.num) {
        if (a2.cell->tag == 4) T_1_3.num = true; else T_1_3.num = false;
        T_1_1.num = T_1_3.num;
    }
    if (T_1_1.num == true) {

  LINE(230);
        {
        {
        CLUREF T_2_1;
        err = c_envOPget_bad_expr(e, &T_2_1);
        if (err != ERR_ok) goto ex_0;
        ret_1->num = T_2_1.num;
        }
        {signal (ERR_ok);}}
        }
    else {

  LINE(231);
        {
        {
        CLUREF T_2_1;
        CLUREF T_2_2;
        generic_CLU_proc.type_owns = 0;
        generic_CLU_proc.op_owns = oneof_a_cons_any__apply_bad_bool__cand__char__cor__down__fetch_force__get_idn_infix_int__invoke_minus_not_null__op_real__ref_s_cons_str_type__type_of__up__ops->entry[1].fcn->op_owns;
        generic_CLU_proc.proc = oneofOPsimilar;
        CUR_PROC_VAR.proc = &generic_CLU_proc;
        err = oneofOPsimilar(a1, a2, &T_2_1);
        if (err != ERR_ok) goto ex_0;
        err = e_b2e(e, T_2_1, &T_2_2);
        if (err != ERR_ok) goto ex_0;
        ret_1->num = T_2_2.num;
        }
        {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 e_applyop ****/


extern errcode e_n2e();
CLUREF STR_copy;
static int e_nullop_own_init = 0;

/**** BEGIN PROCEDURE e_nullop ****/

errcode e_nullop(e, op, args, ret_1)
CLUREF e;
CLUREF op;
CLUREF args;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
        if (e_nullop_own_init == 0) {
        stringOPcons("copy", CLU_1, CLU_4, &STR_copy);
        e_nullop_own_init = 1;
    }
    enter_proc(235);

  LINE(236);
    {
    CLUREF T_1_1;
    T_1_1.num = ((op.str->size != STR_copy.str->size)? false :
        !(bcmp(op.str->data, STR_copy.str->data, op.str->size)));
    if (T_1_1.num == true) {

  LINE(237);
        {
        {
        CLUREF T_2_1;
        err = e_n2e(e, &T_2_1);
        if (err != ERR_ok) goto ex_0;
        ret_1->num = T_2_1.num;
        }
        {signal (ERR_ok);}}
        }
    else {

  LINE(238);
        {
        {
        CLUREF T_2_1;
        err = e_b2e(e, CLU_1, &T_2_1);
        if (err != ERR_ok) goto ex_0;
        ret_1->num = T_2_1.num;
        }
        {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 e_nullop ****/


extern errcode boolOPequal();
CLUREF STR_not;
CLUREF STR_and;
CLUREF STR_or;
static int e_boolop_own_init = 0;

/**** BEGIN PROCEDURE e_boolop ****/

errcode e_boolop(e, op, args, ret_1)
CLUREF e;
CLUREF op;
CLUREF args;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF b1;
    CLUREF b2;
        if (e_boolop_own_init == 0) {
        stringOPcons("not", CLU_1, CLU_3, &STR_not);
        stringOPcons("copy", CLU_1, CLU_4, &STR_copy);
        stringOPcons("and", CLU_1, CLU_3, &STR_and);
        stringOPcons("or", CLU_1, CLU_2, &STR_or);
        e_boolop_own_init = 1;
    }
    enter_proc(242);

  LINE(244);
    {

  LINE(245);
        {
            {CLUREF T_3_1;
            CLUREF T_3_2;
            if (1 < 1 || 1 > args.vec->size ) {
                err = ERR_bounds;
                goto ex_1;}
            T_3_1.num = args.vec->data[1 - 1];
            err = e_e2b(T_3_1, &T_3_2);
            if (err != ERR_ok) goto ex_1;
            b1.num = T_3_2.num;
            }
            }

  LINE(246);
        {
        CLUREF T_3_1;
        T_3_1.num = ((op.str->size != STR_not.str->size)? false :
            !(bcmp(op.str->data, STR_not.str->data, op.str->size)));
        if (T_3_1.num == true) {

  LINE(247);
            {
            CLUREF T_4_1;
            T_4_1.num = b1.num ^ 1;
            b1.num = T_4_1.num;
            }
            }
        else {
        CLUREF T_3_2;
        CLUREF T_3_3;
        T_3_2.num = ((op.str->size != STR_copy.str->size)? false :
            !(bcmp(op.str->data, STR_copy.str->data, op.str->size)));
        T_3_3.num = T_3_2.num ^ 1;
        if (T_3_3.num == true) {

  LINE(249);
            {
                {CLUREF T_4_1;
                CLUREF T_4_2;
                if (2 < 1 || 2 > args.vec->size ) {
                    err = ERR_bounds;
                    goto ex_1;}
                T_4_1.num = args.vec->data[2 - 1];
                err = e_e2b(T_4_1, &T_4_2);
                if (err != ERR_ok) goto ex_1;
                b2.num = T_4_2.num;
                }
                }

  LINE(250);
            {
            CLUREF T_4_1;
            T_4_1.num = ((op.str->size != STR_and.str->size)? false :
                !(bcmp(op.str->data, STR_and.str->data, op.str->size)));
            if (T_4_1.num == true) {

  LINE(251);
                {
                CLUREF T_5_1;
                T_5_1.num = b1.num;
                if (b1.num) {
                    T_5_1.num = b2.num;
                }
                b1.num = T_5_1.num;
                }
                }
            else {
            CLUREF T_4_2;
            T_4_2.num = ((op.str->size != STR_or.str->size)? false :
                !(bcmp(op.str->data, STR_or.str->data, op.str->size)));
            if (T_4_2.num == true) {

  LINE(253);
                {
                CLUREF T_5_1;
                T_5_1.num = b1.num;
                if (!b1.num) {
                    T_5_1.num = b2.num;
                }
                b1.num = T_5_1.num;
                }
                }
            else {

  LINE(254);
                {
                CLUREF T_5_1;
                T_5_1.num = (b1.tf == b2.tf)? true : false;
                b1.num = T_5_1.num;
                }
                }}}/* end if */
            }
            }}/* end if */

  LINE(256);
        {
        {
        CLUREF T_3_1;
        err = e_b2e(e, b1, &T_3_1);
        if (err != ERR_ok) goto ex_1;
        ret_1->num = T_3_1.num;
        }
        {signal (ERR_ok);}}
        }
    goto end_1;
    ex_1:
        if (err == ERR_bad) {signal(ERR_bad);}
        else {
            goto ex_0;}
    end_1:;
    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 e_boolop ****/


extern errcode e_i2e();
extern errcode intOPparse();
extern errcode e_e2s();
extern errcode e_e2i();
extern errcode e_s2e();
extern errcode intOPunparse();
extern errcode intOPminus();
extern errcode intOPabs();
extern errcode intOPadd();
extern errcode intOPsub();
extern errcode intOPmul();
extern errcode intOPdiv();
extern errcode intOPpower();
extern errcode intOPmod();
extern errcode intOPmin();
extern errcode intOPmax();
extern errcode intOPlt();
extern errcode intOPle();
extern errcode intOPge();
extern errcode intOPgt();
CLUREF STR_from_137to_137by;
CLUREF STR_from_137to;
CLUREF STR_parse;
CLUREF STR_unparse;
CLUREF STR_minus;
CLUREF STR_abs;
CLUREF STR_add;
CLUREF STR_sub;
CLUREF STR_mul;
CLUREF STR_div;
CLUREF STR_power;
CLUREF STR_mod;
CLUREF STR_min;
CLUREF STR_max;
CLUREF STR_lt;
CLUREF STR_le;
CLUREF STR_ge;
CLUREF STR_gt;
static int e_intop_own_init = 0;

/**** BEGIN PROCEDURE e_intop ****/

errcode e_intop(e, op, args, ret_1)
CLUREF e;
CLUREF op;
CLUREF args;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF i1;
    CLUREF i2;
    CLUREF b;
    CLUREF err_UNIQ;
        if (e_intop_own_init == 0) {
        stringOPcons("from_to_by", CLU_1, CLU_10, &STR_from_137to_137by);
        stringOPcons("from_to", CLU_1, CLU_7, &STR_from_137to);
        stringOPcons("parse", CLU_1, CLU_5, &STR_parse);
        stringOPcons("unparse", CLU_1, CLU_7, &STR_unparse);
        stringOPcons("minus", CLU_1, CLU_5, &STR_minus);
        stringOPcons("abs", CLU_1, CLU_3, &STR_abs);
        stringOPcons("copy", CLU_1, CLU_4, &STR_copy);
        stringOPcons("add", CLU_1, CLU_3, &STR_add);
        stringOPcons("sub", CLU_1, CLU_3, &STR_sub);
        stringOPcons("mul", CLU_1, CLU_3, &STR_mul);
        stringOPcons("div", CLU_1, CLU_3, &STR_div);
        stringOPcons("power", CLU_1, CLU_5, &STR_power);
        stringOPcons("mod", CLU_1, CLU_3, &STR_mod);
        stringOPcons("min", CLU_1, CLU_3, &STR_min);
        stringOPcons("max", CLU_1, CLU_3, &STR_max);
        stringOPcons("lt", CLU_1, CLU_2, &STR_lt);
        stringOPcons("le", CLU_1, CLU_2, &STR_le);
        stringOPcons("ge", CLU_1, CLU_2, &STR_ge);
        stringOPcons("gt", CLU_1, CLU_2, &STR_gt);
        e_intop_own_init = 1;
    }
    enter_proc(260);

  LINE(262);
    {
    CLUREF T_1_1;
    CLUREF T_1_2;
    CLUREF T_1_3;
    T_1_2.num = ((op.str->size != STR_from_137to_137by.str->size)? false :
        !(bcmp(op.str->data, STR_from_137to_137by.str->data, op.str->size)));
    T_1_1.num = T_1_2.num;
    if (!T_1_2.num) {
        T_1_3.num = ((op.str->size != STR_from_137to.str->size)? false :
            !(bcmp(op.str->data, STR_from_137to.str->data, op.str->size)));
        T_1_1.num = T_1_3.num;
    }
    if (T_1_1.num == true) {

  LINE(263);
        {
        {signal (ERR_illegal);}}
        }
        }/* end if */

  LINE(264);
    {

  LINE(265);
        {
        CLUREF T_3_1;
        T_3_1.num = ((op.str->size != STR_parse.str->size)? false :
            !(bcmp(op.str->data, STR_parse.str->data, op.str->size)));
        if (T_3_1.num == true) {

  LINE(266);
            {
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            CLUREF T_4_3;
            CLUREF T_4_4;
            if (1 < 1 || 1 > args.vec->size ) {
                err = ERR_bounds;
                goto ex_1;}
            T_4_1.num = args.vec->data[1 - 1];
            err = e_e2s(T_4_1, &T_4_2);
            if (err != ERR_ok) goto ex_1;
            err = intOPparse(T_4_2, &T_4_3);
            if (err != ERR_ok) goto ex_1;
            err = e_i2e(e, T_4_3, &T_4_4);
            if (err != ERR_ok) goto ex_1;
            ret_1->num = T_4_4.num;
            }
            {signal (ERR_ok);}}
            }
            }/* end if */

  LINE(267);
        {
            {CLUREF T_3_1;
            CLUREF T_3_2;
            if (1 < 1 || 1 > args.vec->size ) {
                err = ERR_bounds;
                goto ex_1;}
            T_3_1.num = args.vec->data[1 - 1];
            err = e_e2i(T_3_1, &T_3_2);
            if (err != ERR_ok) goto ex_1;
            i1.num = T_3_2.num;
            }
            }

  LINE(268);
        {
        CLUREF T_3_1;
        T_3_1.num = ((op.str->size != STR_unparse.str->size)? false :
            !(bcmp(op.str->data, STR_unparse.str->data, op.str->size)));
        if (T_3_1.num == true) {

  LINE(269);
            {
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            err = intOPunparse(i1, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            err = e_s2e(e, T_4_1, &T_4_2);
            if (err != ERR_ok) goto ex_1;
            ret_1->num = T_4_2.num;
            }
            {signal (ERR_ok);}}
            }
        else {
        CLUREF T_3_2;
        T_3_2.num = ((op.str->size != STR_minus.str->size)? false :
            !(bcmp(op.str->data, STR_minus.str->data, op.str->size)));
        if (T_3_2.num == true) {

  LINE(271);
            {
            CLUREF T_4_1;
            err = intOPminus(i1, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            i1.num = T_4_1.num;
            }
            }
        else {
        CLUREF T_3_3;
        T_3_3.num = ((op.str->size != STR_abs.str->size)? false :
            !(bcmp(op.str->data, STR_abs.str->data, op.str->size)));
        if (T_3_3.num == true) {

  LINE(273);
            {
            CLUREF T_4_1;
            err = intOPabs(i1, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            i1.num = T_4_1.num;
            }
            }
        else {
        CLUREF T_3_4;
        CLUREF T_3_5;
        T_3_4.num = ((op.str->size != STR_copy.str->size)? false :
            !(bcmp(op.str->data, STR_copy.str->data, op.str->size)));
        T_3_5.num = T_3_4.num ^ 1;
        if (T_3_5.num == true) {

  LINE(275);
            {
                {CLUREF T_4_1;
                CLUREF T_4_2;
                if (2 < 1 || 2 > args.vec->size ) {
                    err = ERR_bounds;
                    goto ex_1;}
                T_4_1.num = args.vec->data[2 - 1];
                err = e_e2i(T_4_1, &T_4_2);
                if (err != ERR_ok) goto ex_1;
                i2.num = T_4_2.num;
                }
                }

  LINE(276);
            {
            CLUREF T_4_1;
            T_4_1.num = ((op.str->size != STR_add.str->size)? false :
                !(bcmp(op.str->data, STR_add.str->data, op.str->size)));
            if (T_4_1.num == true) {

  LINE(277);
                {
                CLUREF T_5_1;
                T_5_1.num = i1.num + i2.num;
                 if ((T_5_1.num > 0 && i1.num < 0 && i2.num < 0) || 
                     (T_5_1.num < 0 && i1.num > 0 && i2.num > 0)) {
                    err = ERR_overflow;
                    goto ex_1;}
                i1.num = T_5_1.num;
                }
                }
            else {
            CLUREF T_4_2;
            T_4_2.num = ((op.str->size != STR_sub.str->size)? false :
                !(bcmp(op.str->data, STR_sub.str->data, op.str->size)));
            if (T_4_2.num == true) {

  LINE(279);
                {
                CLUREF T_5_1;
                T_5_1.num = i1.num - i2.num;
                 if ((T_5_1.num >= 0 && i1.num < 0 && (-i2.num) < 0) || 
                     (T_5_1.num <= 0 && i1.num > 0 && (-i2.num) > 0)) {
                    err = ERR_overflow;
                    goto ex_1;}
                i1.num = T_5_1.num;
                }
                }
            else {
            CLUREF T_4_3;
            T_4_3.num = ((op.str->size != STR_mul.str->size)? false :
                !(bcmp(op.str->data, STR_mul.str->data, op.str->size)));
            if (T_4_3.num == true) {

  LINE(281);
                {
                CLUREF T_5_1;
                err = intOPmul(i1, i2, &T_5_1);
                if (err != ERR_ok) goto ex_1;
                i1.num = T_5_1.num;
                }
                }
            else {
            CLUREF T_4_4;
            T_4_4.num = ((op.str->size != STR_div.str->size)? false :
                !(bcmp(op.str->data, STR_div.str->data, op.str->size)));
            if (T_4_4.num == true) {

  LINE(283);
                {
                CLUREF T_5_1;
                err = intOPdiv(i1, i2, &T_5_1);
                if (err != ERR_ok) goto ex_1;
                i1.num = T_5_1.num;
                }
                }
            else {
            CLUREF T_4_5;
            T_4_5.num = ((op.str->size != STR_power.str->size)? false :
                !(bcmp(op.str->data, STR_power.str->data, op.str->size)));
            if (T_4_5.num == true) {

  LINE(285);
                {
                CLUREF T_5_1;
                err = intOPpower(i1, i2, &T_5_1);
                if (err != ERR_ok) goto ex_1;
                i1.num = T_5_1.num;
                }
                }
            else {
            CLUREF T_4_6;
            T_4_6.num = ((op.str->size != STR_mod.str->size)? false :
                !(bcmp(op.str->data, STR_mod.str->data, op.str->size)));
            if (T_4_6.num == true) {

  LINE(287);
                {
                CLUREF T_5_1;
                err = intOPmod(i1, i2, &T_5_1);
                if (err != ERR_ok) goto ex_1;
                i1.num = T_5_1.num;
                }
                }
            else {
            CLUREF T_4_7;
            T_4_7.num = ((op.str->size != STR_min.str->size)? false :
                !(bcmp(op.str->data, STR_min.str->data, op.str->size)));
            if (T_4_7.num == true) {

  LINE(289);
                {
                CLUREF T_5_1;
                err = intOPmin(i1, i2, &T_5_1);
                if (err != ERR_ok) goto ex_1;
                i1.num = T_5_1.num;
                }
                }
            else {
            CLUREF T_4_8;
            T_4_8.num = ((op.str->size != STR_max.str->size)? false :
                !(bcmp(op.str->data, STR_max.str->data, op.str->size)));
            if (T_4_8.num == true) {

  LINE(291);
                {
                CLUREF T_5_1;
                err = intOPmax(i1, i2, &T_5_1);
                if (err != ERR_ok) goto ex_1;
                i1.num = T_5_1.num;
                }
                }
            else {

  LINE(293);
                {
                CLUREF T_5_1;
                T_5_1.num = ((op.str->size != STR_lt.str->size)? false :
                    !(bcmp(op.str->data, STR_lt.str->data, op.str->size)));
                if (T_5_1.num == true) {

  LINE(294);
                    {
                    CLUREF T_6_1;
                    T_6_1.num = (i1.num < i2.num)? true : false;
                    b.num = T_6_1.num;
                    }
                    }
                else {
                CLUREF T_5_2;
                T_5_2.num = ((op.str->size != STR_le.str->size)? false :
                    !(bcmp(op.str->data, STR_le.str->data, op.str->size)));
                if (T_5_2.num == true) {

  LINE(296);
                    {
                    CLUREF T_6_1;
                    T_6_1.num = (i1.num <= i2.num)? true : false;
                    b.num = T_6_1.num;
                    }
                    }
                else {
                CLUREF T_5_3;
                T_5_3.num = ((op.str->size != STR_ge.str->size)? false :
                    !(bcmp(op.str->data, STR_ge.str->data, op.str->size)));
                if (T_5_3.num == true) {

  LINE(298);
                    {
                    CLUREF T_6_1;
                    T_6_1.num = (i1.num >= i2.num)? true : false;
                    b.num = T_6_1.num;
                    }
                    }
                else {
                CLUREF T_5_4;
                T_5_4.num = ((op.str->size != STR_gt.str->size)? false :
                    !(bcmp(op.str->data, STR_gt.str->data, op.str->size)));
                if (T_5_4.num == true) {

  LINE(300);
                    {
                    CLUREF T_6_1;
                    T_6_1.num = (i1.num > i2.num)? true : false;
                    b.num = T_6_1.num;
                    }
                    }
                else {

  LINE(301);
                    {
                    CLUREF T_6_1;
                    T_6_1.num = (i1.num == i2.num)? true : false;
                    b.num = T_6_1.num;
                    }
                    }}}}}/* end if */

  LINE(302);
                {
                {
                CLUREF T_5_1;
                err = e_b2e(e, b, &T_5_1);
                if (err != ERR_ok) goto ex_1;
                ret_1->num = T_5_1.num;
                }
                {signal (ERR_ok);}}
                }}}}}}}}}/* end if */
            }
            }}}}/* end if */

  LINE(305);
        {
        {
        CLUREF T_3_1;
        err = e_i2e(e, i1, &T_3_1);
        if (err != ERR_ok) goto ex_1;
        ret_1->num = T_3_1.num;
        }
        {signal (ERR_ok);}}
        }
        goto end_1;
        ex_1:
            if ((err == ERR_bad)) {

  LINE(306);
                {
                {signal (ERR_bad);}}
            }
            else {
                CLUREF err_UNIQ;
                err_UNIQ.num = elist[0].num;

  LINE(307);
                {
                elist[0] = err_UNIQ;
                {signal (ERR_error);}}
            }
        end_1:;
    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 e_intop ****/


extern errcode e_r2e();
extern errcode realOPi2r();
extern errcode realOPparse();
extern errcode e_e2r();
extern errcode realOPr2i();
extern errcode realOPtrunc();
extern errcode realOPunparse();
extern errcode realOPexponent();
extern errcode realOPminus();
extern errcode realOPabs();
extern errcode realOPmantissa();
extern errcode realOPadd();
extern errcode realOPsub();
extern errcode realOPmul();
extern errcode realOPdiv();
extern errcode realOPpower();
extern errcode realOPmin();
extern errcode realOPmax();
extern errcode realOPlt();
extern errcode realOPle();
extern errcode realOPge();
extern errcode realOPgt();
extern errcode realOPequal();
CLUREF STR_i2r;
CLUREF STR_r2i;
CLUREF STR_trunc;
CLUREF STR_exponent;
CLUREF STR_mantissa;
static int e_realop_own_init = 0;

/**** BEGIN PROCEDURE e_realop ****/

errcode e_realop(e, op, args, ret_1)
CLUREF e;
CLUREF op;
CLUREF args;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF a1;
    CLUREF r1;
    CLUREF r2;
    CLUREF b;
    CLUREF err_UNIQ;
        if (e_realop_own_init == 0) {
        stringOPcons("i2r", CLU_1, CLU_3, &STR_i2r);
        stringOPcons("parse", CLU_1, CLU_5, &STR_parse);
        stringOPcons("r2i", CLU_1, CLU_3, &STR_r2i);
        stringOPcons("trunc", CLU_1, CLU_5, &STR_trunc);
        stringOPcons("unparse", CLU_1, CLU_7, &STR_unparse);
        stringOPcons("exponent", CLU_1, CLU_8, &STR_exponent);
        stringOPcons("minus", CLU_1, CLU_5, &STR_minus);
        stringOPcons("abs", CLU_1, CLU_3, &STR_abs);
        stringOPcons("mantissa", CLU_1, CLU_8, &STR_mantissa);
        stringOPcons("copy", CLU_1, CLU_4, &STR_copy);
        stringOPcons("add", CLU_1, CLU_3, &STR_add);
        stringOPcons("sub", CLU_1, CLU_3, &STR_sub);
        stringOPcons("mul", CLU_1, CLU_3, &STR_mul);
        stringOPcons("div", CLU_1, CLU_3, &STR_div);
        stringOPcons("power", CLU_1, CLU_5, &STR_power);
        stringOPcons("min", CLU_1, CLU_3, &STR_min);
        stringOPcons("max", CLU_1, CLU_3, &STR_max);
        stringOPcons("lt", CLU_1, CLU_2, &STR_lt);
        stringOPcons("le", CLU_1, CLU_2, &STR_le);
        stringOPcons("ge", CLU_1, CLU_2, &STR_ge);
        stringOPcons("gt", CLU_1, CLU_2, &STR_gt);
        e_realop_own_init = 1;
    }
    enter_proc(311);

  LINE(313);
    {

  LINE(314);
        {
            {CLUREF T_3_1;
            if (1 < 1 || 1 > args.vec->size ) {
                err = ERR_bounds;
                goto ex_1;}
            T_3_1.num = args.vec->data[1 - 1];
            a1.num = T_3_1.num;
            }
            }

  LINE(315);
        {
        CLUREF T_3_1;
        T_3_1.num = ((op.str->size != STR_i2r.str->size)? false :
            !(bcmp(op.str->data, STR_i2r.str->data, op.str->size)));
        if (T_3_1.num == true) {

  LINE(316);
            {
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            CLUREF T_4_3;
            err = e_e2i(a1, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            err = realOPi2r(T_4_1, &T_4_2);
            if (err != ERR_ok) goto ex_1;
            err = e_r2e(e, T_4_2, &T_4_3);
            if (err != ERR_ok) goto ex_1;
            ret_1->num = T_4_3.num;
            }
            {signal (ERR_ok);}}
            }
        else {
        CLUREF T_3_2;
        T_3_2.num = ((op.str->size != STR_parse.str->size)? false :
            !(bcmp(op.str->data, STR_parse.str->data, op.str->size)));
        if (T_3_2.num == true) {

  LINE(318);
            {
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            CLUREF T_4_3;
            err = e_e2s(a1, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            err = realOPparse(T_4_1, &T_4_2);
            if (err != ERR_ok) goto ex_1;
            err = e_r2e(e, T_4_2, &T_4_3);
            if (err != ERR_ok) goto ex_1;
            ret_1->num = T_4_3.num;
            }
            {signal (ERR_ok);}}
            }
            }}/* end if */

  LINE(319);
        {
            {CLUREF T_3_1;
            CLUREF T_3_2;
            if (1 < 1 || 1 > args.vec->size ) {
                err = ERR_bounds;
                goto ex_1;}
            T_3_1.num = args.vec->data[1 - 1];
            err = e_e2r(T_3_1, &T_3_2);
            if (err != ERR_ok) goto ex_1;
            r1.num = T_3_2.num;
            }
            }

  LINE(320);
        {
        CLUREF T_3_1;
        T_3_1.num = ((op.str->size != STR_r2i.str->size)? false :
            !(bcmp(op.str->data, STR_r2i.str->data, op.str->size)));
        if (T_3_1.num == true) {

  LINE(321);
            {
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            err = realOPr2i(r1, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            err = e_i2e(e, T_4_1, &T_4_2);
            if (err != ERR_ok) goto ex_1;
            ret_1->num = T_4_2.num;
            }
            {signal (ERR_ok);}}
            }
        else {
        CLUREF T_3_2;
        T_3_2.num = ((op.str->size != STR_trunc.str->size)? false :
            !(bcmp(op.str->data, STR_trunc.str->data, op.str->size)));
        if (T_3_2.num == true) {

  LINE(323);
            {
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            err = realOPtrunc(r1, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            err = e_i2e(e, T_4_1, &T_4_2);
            if (err != ERR_ok) goto ex_1;
            ret_1->num = T_4_2.num;
            }
            {signal (ERR_ok);}}
            }
        else {
        CLUREF T_3_3;
        T_3_3.num = ((op.str->size != STR_unparse.str->size)? false :
            !(bcmp(op.str->data, STR_unparse.str->data, op.str->size)));
        if (T_3_3.num == true) {

  LINE(325);
            {
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            err = realOPunparse(r1, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            err = e_s2e(e, T_4_1, &T_4_2);
            if (err != ERR_ok) goto ex_1;
            ret_1->num = T_4_2.num;
            }
            {signal (ERR_ok);}}
            }
        else {
        CLUREF T_3_4;
        T_3_4.num = ((op.str->size != STR_exponent.str->size)? false :
            !(bcmp(op.str->data, STR_exponent.str->data, op.str->size)));
        if (T_3_4.num == true) {

  LINE(327);
            {
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            err = realOPexponent(r1, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            err = e_i2e(e, T_4_1, &T_4_2);
            if (err != ERR_ok) goto ex_1;
            ret_1->num = T_4_2.num;
            }
            {signal (ERR_ok);}}
            }
        else {
        CLUREF T_3_5;
        T_3_5.num = ((op.str->size != STR_minus.str->size)? false :
            !(bcmp(op.str->data, STR_minus.str->data, op.str->size)));
        if (T_3_5.num == true) {

  LINE(329);
            {
            CLUREF T_4_1;
            err = realOPminus(r1, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            r1.num = T_4_1.num;
            }
            }
        else {
        CLUREF T_3_6;
        T_3_6.num = ((op.str->size != STR_abs.str->size)? false :
            !(bcmp(op.str->data, STR_abs.str->data, op.str->size)));
        if (T_3_6.num == true) {

  LINE(331);
            {
            CLUREF T_4_1;
            err = realOPabs(r1, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            r1.num = T_4_1.num;
            }
            }
        else {
        CLUREF T_3_7;
        T_3_7.num = ((op.str->size != STR_mantissa.str->size)? false :
            !(bcmp(op.str->data, STR_mantissa.str->data, op.str->size)));
        if (T_3_7.num == true) {

  LINE(333);
            {
            CLUREF T_4_1;
            err = realOPmantissa(r1, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            r1.num = T_4_1.num;
            }
            }
        else {
        CLUREF T_3_8;
        CLUREF T_3_9;
        T_3_8.num = ((op.str->size != STR_copy.str->size)? false :
            !(bcmp(op.str->data, STR_copy.str->data, op.str->size)));
        T_3_9.num = T_3_8.num ^ 1;
        if (T_3_9.num == true) {

  LINE(335);
            {
                {CLUREF T_4_1;
                CLUREF T_4_2;
                if (2 < 1 || 2 > args.vec->size ) {
                    err = ERR_bounds;
                    goto ex_1;}
                T_4_1.num = args.vec->data[2 - 1];
                err = e_e2r(T_4_1, &T_4_2);
                if (err != ERR_ok) goto ex_1;
                r2.num = T_4_2.num;
                }
                }

  LINE(336);
            {
            CLUREF T_4_1;
            T_4_1.num = ((op.str->size != STR_add.str->size)? false :
                !(bcmp(op.str->data, STR_add.str->data, op.str->size)));
            if (T_4_1.num == true) {

  LINE(337);
                {
                CLUREF T_5_1;
                err = realOPadd(r1, r2, &T_5_1);
                if (err != ERR_ok) goto ex_1;
                r1.num = T_5_1.num;
                }
                }
            else {
            CLUREF T_4_2;
            T_4_2.num = ((op.str->size != STR_sub.str->size)? false :
                !(bcmp(op.str->data, STR_sub.str->data, op.str->size)));
            if (T_4_2.num == true) {

  LINE(339);
                {
                CLUREF T_5_1;
                err = realOPsub(r1, r2, &T_5_1);
                if (err != ERR_ok) goto ex_1;
                r1.num = T_5_1.num;
                }
                }
            else {
            CLUREF T_4_3;
            T_4_3.num = ((op.str->size != STR_mul.str->size)? false :
                !(bcmp(op.str->data, STR_mul.str->data, op.str->size)));
            if (T_4_3.num == true) {

  LINE(341);
                {
                CLUREF T_5_1;
                err = realOPmul(r1, r2, &T_5_1);
                if (err != ERR_ok) goto ex_1;
                r1.num = T_5_1.num;
                }
                }
            else {
            CLUREF T_4_4;
            T_4_4.num = ((op.str->size != STR_div.str->size)? false :
                !(bcmp(op.str->data, STR_div.str->data, op.str->size)));
            if (T_4_4.num == true) {

  LINE(343);
                {
                CLUREF T_5_1;
                err = realOPdiv(r1, r2, &T_5_1);
                if (err != ERR_ok) goto ex_1;
                r1.num = T_5_1.num;
                }
                }
            else {
            CLUREF T_4_5;
            T_4_5.num = ((op.str->size != STR_power.str->size)? false :
                !(bcmp(op.str->data, STR_power.str->data, op.str->size)));
            if (T_4_5.num == true) {

  LINE(345);
                {
                CLUREF T_5_1;
                err = realOPpower(r1, r2, &T_5_1);
                if (err != ERR_ok) goto ex_1;
                r1.num = T_5_1.num;
                }
                }
            else {
            CLUREF T_4_6;
            T_4_6.num = ((op.str->size != STR_min.str->size)? false :
                !(bcmp(op.str->data, STR_min.str->data, op.str->size)));
            if (T_4_6.num == true) {

  LINE(347);
                {
                CLUREF T_5_1;
                err = realOPmin(r1, r2, &T_5_1);
                if (err != ERR_ok) goto ex_1;
                r1.num = T_5_1.num;
                }
                }
            else {
            CLUREF T_4_7;
            T_4_7.num = ((op.str->size != STR_max.str->size)? false :
                !(bcmp(op.str->data, STR_max.str->data, op.str->size)));
            if (T_4_7.num == true) {

  LINE(349);
                {
                CLUREF T_5_1;
                err = realOPmax(r1, r2, &T_5_1);
                if (err != ERR_ok) goto ex_1;
                r1.num = T_5_1.num;
                }
                }
            else {

  LINE(351);
                {
                CLUREF T_5_1;
                T_5_1.num = ((op.str->size != STR_lt.str->size)? false :
                    !(bcmp(op.str->data, STR_lt.str->data, op.str->size)));
                if (T_5_1.num == true) {

  LINE(352);
                    {
                    CLUREF T_6_1;
                    err = realOPlt(r1, r2, &T_6_1);
                    if (err != ERR_ok) goto ex_1;
                    b.num = T_6_1.num;
                    }
                    }
                else {
                CLUREF T_5_2;
                T_5_2.num = ((op.str->size != STR_le.str->size)? false :
                    !(bcmp(op.str->data, STR_le.str->data, op.str->size)));
                if (T_5_2.num == true) {

  LINE(354);
                    {
                    CLUREF T_6_1;
                    err = realOPle(r1, r2, &T_6_1);
                    if (err != ERR_ok) goto ex_1;
                    b.num = T_6_1.num;
                    }
                    }
                else {
                CLUREF T_5_3;
                T_5_3.num = ((op.str->size != STR_ge.str->size)? false :
                    !(bcmp(op.str->data, STR_ge.str->data, op.str->size)));
                if (T_5_3.num == true) {

  LINE(356);
                    {
                    CLUREF T_6_1;
                    err = realOPge(r1, r2, &T_6_1);
                    if (err != ERR_ok) goto ex_1;
                    b.num = T_6_1.num;
                    }
                    }
                else {
                CLUREF T_5_4;
                T_5_4.num = ((op.str->size != STR_gt.str->size)? false :
                    !(bcmp(op.str->data, STR_gt.str->data, op.str->size)));
                if (T_5_4.num == true) {

  LINE(358);
                    {
                    CLUREF T_6_1;
                    err = realOPgt(r1, r2, &T_6_1);
                    if (err != ERR_ok) goto ex_1;
                    b.num = T_6_1.num;
                    }
                    }
                else {

  LINE(359);
                    {
                    CLUREF T_6_1;
                    err = realOPequal(r1, r2, &T_6_1);
                    if (err != ERR_ok) goto ex_1;
                    b.num = T_6_1.num;
                    }
                    }}}}}/* end if */

  LINE(360);
                {
                {
                CLUREF T_5_1;
                err = e_b2e(e, b, &T_5_1);
                if (err != ERR_ok) goto ex_1;
                ret_1->num = T_5_1.num;
                }
                {signal (ERR_ok);}}
                }}}}}}}}/* end if */
            }
            }}}}}}}}/* end if */

  LINE(363);
        {
        {
        CLUREF T_3_1;
        err = e_r2e(e, r1, &T_3_1);
        if (err != ERR_ok) goto ex_1;
        ret_1->num = T_3_1.num;
        }
        {signal (ERR_ok);}}
        }
        goto end_1;
        ex_1:
            if ((err == ERR_bad)) {

  LINE(364);
                {
                {signal (ERR_bad);}}
            }
            else {
                CLUREF err_UNIQ;
                err_UNIQ.num = elist[0].num;

  LINE(365);
                {
                elist[0] = err_UNIQ;
                {signal (ERR_error);}}
            }
        end_1:;
    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 e_realop ****/


extern errcode e_h2e();
extern errcode charOPi2c();
extern errcode e_e2h();
extern errcode charOPc2i();
extern errcode charOPlt();
extern errcode charOPle();
extern errcode charOPge();
extern errcode charOPgt();
extern errcode charOPequal();
CLUREF STR_i2c;
CLUREF STR_c2i;
static int e_charop_own_init = 0;

/**** BEGIN PROCEDURE e_charop ****/

errcode e_charop(e, op, args, ret_1)
CLUREF e;
CLUREF op;
CLUREF args;
CLUREF *ret_1;
    {
    errcode err;
    errcode ecode2;
    CLUREF a1;
    CLUREF h1;
    CLUREF h2;
    CLUREF b;
    CLUREF err_UNIQ;
        if (e_charop_own_init == 0) {
        stringOPcons("i2c", CLU_1, CLU_3, &STR_i2c);
        stringOPcons("c2i", CLU_1, CLU_3, &STR_c2i);
        stringOPcons("copy", CLU_1, CLU_4, &STR_copy);
        stringOPcons("lt", CLU_1, CLU_2, &STR_lt);
        stringOPcons("le", CLU_1, CLU_2, &STR_le);
        stringOPcons("ge", CLU_1, CLU_2, &STR_ge);
        stringOPcons("gt", CLU_1, CLU_2, &STR_gt);
        e_charop_own_init = 1;
    }
    enter_proc(369);

  LINE(371);
    {

  LINE(372);
        {
            {CLUREF T_3_1;
            if (1 < 1 || 1 > args.vec->size ) {
                err = ERR_bounds;
                goto ex_1;}
            T_3_1.num = args.vec->data[1 - 1];
            a1.num = T_3_1.num;
            }
            }

  LINE(373);
        {
        CLUREF T_3_1;
        T_3_1.num = ((op.str->size != STR_i2c.str->size)? false :
            !(bcmp(op.str->data, STR_i2c.str->data, op.str->size)));
        if (T_3_1.num == true) {

  LINE(374);
            {
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            CLUREF T_4_3;
            err = e_e2i(a1, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            err = charOPi2c(T_4_1, &T_4_2);
            if (err != ERR_ok) goto ex_1;
            err = e_h2e(e, T_4_2, &T_4_3);
            if (err != ERR_ok) goto ex_1;
            ret_1->num = T_4_3.num;
            }
            {signal (ERR_ok);}}
            }
            }/* end if */

  LINE(375);
        {
            {CLUREF T_3_1;
            err = e_e2h(a1, &T_3_1);
            if (err != ERR_ok) goto ex_1;
            h1.num = T_3_1.num;
            }
            }

  LINE(376);
        {
        CLUREF T_3_1;
        T_3_1.num = ((op.str->size != STR_c2i.str->size)? false :
            !(bcmp(op.str->data, STR_c2i.str->data, op.str->size)));
        if (T_3_1.num == true) {

  LINE(377);
            {
            {
            CLUREF T_4_1;
            CLUREF T_4_2;
            T_4_1.num = (int)(h1.ch & 0xff);
            err = e_i2e(e, T_4_1, &T_4_2);
            if (err != ERR_ok) goto ex_1;
            ret_1->num = T_4_2.num;
            }
            {signal (ERR_ok);}}
            }
        else {
        CLUREF T_3_2;
        T_3_2.num = ((op.str->size != STR_copy.str->size)? false :
            !(bcmp(op.str->data, STR_copy.str->data, op.str->size)));
        if (T_3_2.num == true) {

  LINE(379);
            {
            {
            ret_1->num = a1.num;
            }
            {signal (ERR_ok);}}
            }
            }}/* end if */

  LINE(380);
        {
            {CLUREF T_3_1;
            CLUREF T_3_2;
            if (2 < 1 || 2 > args.vec->size ) {
                err = ERR_bounds;
                goto ex_1;}
            T_3_1.num = args.vec->data[2 - 1];
            err = e_e2h(T_3_1, &T_3_2);
            if (err != ERR_ok) goto ex_1;
            h2.num = T_3_2.num;
            }
            }

  LINE(382);
        {
        CLUREF T_3_1;
        T_3_1.num = ((op.str->size != STR_lt.str->size)? false :
            !(bcmp(op.str->data, STR_lt.str->data, op.str->size)));
        if (T_3_1.num == true) {

  LINE(383);
            {
            CLUREF T_4_1;
            err = charOPlt(h1, h2, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            b.num = T_4_1.num;
            }
            }
        else {
        CLUREF T_3_2;
        T_3_2.num = ((op.str->size != STR_le.str->size)? false :
            !(bcmp(op.str->data, STR_le.str->data, op.str->size)));
        if (T_3_2.num == true) {

  LINE(385);
            {
            CLUREF T_4_1;
            err = charOPle(h1, h2, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            b.num = T_4_1.num;
            }
            }
        else {
        CLUREF T_3_3;
        T_3_3.num = ((op.str->size != STR_ge.str->size)? false :
            !(bcmp(op.str->data, STR_ge.str->data, op.str->size)));
        if (T_3_3.num == true) {

  LINE(387);
            {
            CLUREF T_4_1;
            err = charOPge(h1, h2, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            b.num = T_4_1.num;
            }
            }
        else {
        CLUREF T_3_4;
        T_3_4.num = ((op.str->size != STR_gt.str->size)? false :
            !(bcmp(op.str->data, STR_gt.str->data, op.str->size)));
        if (T_3_4.num == true) {

  LINE(389);
            {
            CLUREF T_4_1;
            err = charOPgt(h1, h2, &T_4_1);
            if (err != ERR_ok) goto ex_1;
            b.num = T_4_1.num;
            }
            }
        else {

  LINE(390);
            {
            CLUREF T_4_1;
            T_4_1.num = (h1.ch == h2.ch)? true : false;
            b.num = T_4_1.num;
            }
            }}}}}/* end if */

  LINE(391);
        {
        {
        CLUREF T_3_1;
        err = e_b2e(e, b, &T_3_1);
        if (err != ERR_ok) goto ex_1;
        ret_1->num = T_3_1.num;
        }
        {signal (ERR_ok);}}
        }
        goto end_1;
        ex_1:
            if ((err == ERR_bad)) {

  LINE(392);
                {
                {signal (ERR_bad);}}
            }
            else {
                CLUREF err_UNIQ;
                err_UNIQ.num = elist[0].num;

  LINE(393);
                {
                elist[0] = err_UNIQ;
                {signal (ERR_error);}}
            }
        end_1:;
    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 e_charop ****/