// $Source$
// $Revision$
// $Date$

$use Class StdIO Arithm Compare Box Table;

// Stack for optimization of expr-int: (s.flag s.int)...()...
$box Stack-Int;

// table of used label (break, continue)
$table Used-Label;

$func Optim-Int  e.int = e.expr-int; 

$func Optim-Expr (e.init) e.rest = e.expr-optim;

$func Optim-Ref e.expr = e.expr-ref;

$func Optim-MAX  (e.work-int) (e.res) e.rest = e.expr-max;

$func Optim-MIN e.x = e.y;
// $func Optim-MIN (e.work-int) (e.res) e.rest = e.expr-min; 

$func Optim-Add (s.res) (e.expr) e.expr-int = e.add;

$func Optim-Minus (e.first) (e.expr) (s.int) e.expr-int = e.res;

$func Optim-Mult (s.res) (e.expr) e.expr-int = e.mult;

$func Optim-Div e.expr-int = e.res;

$func Optim-Rem e.rest = e.res;

$func Optim-Cond-Int s.op e.args = e.res;

$func Optim-Cond (e.init) e.cond = e.res;

$func Optim-Log-Args e.args = e.res;

$func Optim-Cond-Log s.op e.args = e.res;

$func AND-Args e.args = e.res;

$func OR-Args e.args = e.res;

$func Optim-Int-Args e.args = e.optim-args;

$func Optim-Log-Expr e.log-expr = e.res; 

// function for Stack-Int
$func Push = ;

$func Pop  = e.int;

$func Add-Stack-Int s.int = ;

$func Add-Stack-Flag  = ;

$func Args-Paren (e.init) e.rest  = (e.res);

$func Int-Paren e.init = e.res;

$func Neg-Sign e.int = s.sign;

$func Del-Neg  e.int = e.res;

$func Neg-Optim e.int = e.optim;

// Deleting of unused label on level of function
$func Correct-Label e.func-body = e.body;

// Clear of table
$func Clear-Table s.table e.key = ;

$func Label-In-Table e.label =  e.maybe-empty ;

ASAIL-Optim  e.asail, e.asail: {
  /*empty*/ = /*empty*/;
  t.item e.rest = 
  t.item : {
    (FUNC t.name t.args t.ress e.body) =
      <Clear-Table &Used-Label <Domain &Used-Label>>, 
      <ASAIL-Optim e.body> :: e.body,
      <Correct-Label e.body> :: e.body, 
      (FUNC t.name t.args t.ress e.body);
    (IF (e.cond) e.body) =
      <Optim-Cond () e.cond > :: e.res-cond, 
        {
          e.res-cond: (0) = /*empty*/;
          <ASAIL-Optim e.body> :: e.body, 
            {
              e.res-cond : (1) = (LABEL () e.body);
              (IF (e.res-cond) e.body);
            };
        };  
    (FOR (e.cont-label) (e.break-label) (e.cond) (e.step) e.body) =
      <ASAIL-Optim e.body> :: e.body,			
      (FOR (e.cont-label) (e.break-label) (e.cond) (e.step) e.body);
    (LABEL t.label e.body) = <ASAIL-Optim e.body> :: e.body,
      (LABEL t.label e.body) ;
    (TRY e.body) = <ASAIL-Optim e.body> :: e.body,
      (TRY e.body);
    (CATCH-ERROR e.body) =<ASAIL-Optim e.body> :: e.body, 
      (CATCH-ERROR e.body);
    (LSPLIT e.expr (e.min) t.var1 t.var2) = 
      <Optim-Ref e.expr> :: e.expr,
      <Push><Optim-Int e.min> :: e.min,
      (LSPLIT e.expr (e.min) t.var1 t.var2) ;
    (RSPLIT e.expr (e.min) t.var1 t.var2) =
      <Optim-Ref e.expr> :: e.expr,
      <Push><Optim-Int e.min> :: e.min,		
      (RSPLIT e.expr (e.min) t.var1 t.var2) ;
    (ASSIGN t.var e.expr) = 
      <Optim-Expr () e.expr> :: e.expr,
      (ASSIGN t.var e.expr);
    (INT t.var e.expr) =
       <Push> <Optim-Int e.expr> :: e.expr,
      (INT t.var e.expr);
    (EXPR t.var e.expr) = <Optim-Ref e.expr> :: e.expr,
      (EXPR t.var e.expr);
    (DEREF t.var e.expr (e.pos)) =
      <Optim-Ref e.expr> :: e.expr,
      (DEREF t.var e.expr (<Push> <Optim-Int e.pos>));
    (SUBEXPR t.var e.expr (e.pos) (e.len)) =
      <Optim-Ref e.expr> :: e.expr,
      (SUBEXPR t.var e.expr
        (<Push> <Optim-Int e.pos>)
        (<Push> <Optim-Int e.len> ) ) ;
//  RETURN=RETURN;
//  RETFAIL=RETFAIL;
//  FATAL=FATAL;
//  (DECL e1) = (DECL e1);
//  (DROP e1) = (DROP e1);
    (CONTINUE t.label) =  
      <Bind &Used-Label (t.label) ()>
      (CONTINUE t.label ) ;
    (BREAK t.label ) =  
      <Bind &Used-Label (t.label) ()>
      (BREAK t.label ) ;
//  (ERROR e1) = (ERROR e1);
//  (CONSTEXPR e1) = (CONSTEXPR e1);
//  (DECL-CONST t.name) = (DECL-CONST t.name);
//  (DECL-OBJ e.obj) = (DECL-OBJ e.obj);
//  (DECL-FUNC e1) = (DECL-FUNC e1);
//  (s.call t.name (e.exprs) (e.ress)) = (s.call t.name (e.exprs)(e.ress));
    t.item = t.item ; 
    } :: e.cpp-item,
  e.cpp-item <ASAIL-Optim e.rest>;
};

Optim-Expr  (e.init) e.expr-all, e.expr-all : {
  /*empty*/ = e.init;
  s.ObjectSymbol e.rest, 
    {
      <Int? s.ObjectSymbol> = <Push> 
        <Optim-Int e.init e.expr-all>;
      <Optim-Ref e.init  e.expr-all> ; 
    };   
  (LENGTH e.expr) e.rest = <Push> <Optim-Int e.init e.expr-all> ;
  (MAX e.args) e.rest = <Push> <Optim-Int e.init e.expr-all>;       
  (MIN e.args) e.rest = <Push> <Optim-Int e.init e.expr-all>;
  (INFIX s.op e.args) e.rest = <Push> <Optim-Int e.init e.expr-all>;
  (PAREN e.expr) e.rest = <Optim-Ref e.init e.expr-all>;
  (EXPR e.expr) e.rest = <Optim-Ref e.init e.expr-all>;
  (DEREF e.expr) e.rest = <Optim-Ref e.init  e.expr-all>;
  (SUBEXPR e.expr) e.rest = <Optim-Ref e.init e.expr-all>;
  t.var e.rest = <Optim-Expr (e.init t.var) e.rest>;
};

Optim-Ref  {  
  /*empty*/ = /*empty*/;
  t.item e.rest = t.item : {
    s.ObjectSymbol = s.ObjectSymbol;
    (PAREN e.expr) = (PAREN <Optim-Ref e.expr> );
    (EXPR e.expr) = (EXPR <Optim-Ref e.expr> );
    (DEREF e.expr (e.pos)) = 
      (DEREF <Optim-Ref e.expr> (<Push> <Optim-Int e.pos>));
    (SUBEXPR e.expr (e.pos) (e.len)) = 
      (SUBEXPR <Optim-Ref e.expr> (<Push> <Optim-Int e.pos>)
        (<Push> <Optim-Int e.len>)) ;
    t.var  = t.var ;
    } :: e.cpp-item,
  e.cpp-item  <Optim-Ref e.rest>;
};

Optim-Int {
  /*empty*/ = <Pop>;
  t.item e.rest = t.item : {
    s.ObjectSymbol = s.ObjectSymbol;
    (LENGTH e.expr) = (LENGTH <Optim-Ref e.expr>);
    (MAX e.args) = <Optim-Int-Args e.args> :: e.args,
      <Optim-MAX () () e.args>;
    (MIN e.args) = <Optim-Int-Args e.args> :: e.args,
      <Optim-MIN () () e.args> ;
    (INFIX s.op e.args ) = s.op: {
      "+" = <Optim-Int-Args e.args> :: e.args,
        <Optim-Add (0) () e.args>;
      "-" = <Optim-Int-Args e.args> :: e.args,
        <Optim-Minus () () (0) e.args>;
      "*" = <Optim-Int-Args e.args> :: e.args,
        <Optim-Mult (1) () e.args> ;
      "/" = <Optim-Int-Args e.args> :: e.args,
        <Optim-Div e.args > ;
      "%" = <Optim-Int-Args e.args> :: e.args,
        <Optim-Rem e.args>;
      };
    t.var = t.var;
  } :: e.int-item, 
  {
    e.int-item : s.numb = <Add-Stack-Int s.numb> <Optim-Int e.rest>; 
    <Add-Stack-Flag> e.int-item <Optim-Int e.rest>;
  };
};

Optim-Int-Args  {
  /*empty*/ = /*empty*/;
  (s.int) e.rest = (s.int) <Optim-Int-Args e.rest>;
  (e.arg) e.rest = <Push>, 
    <Optim-Int e.arg> :: e.res, 
    <Args-Paren () e.res> <Optim-Int-Args e.rest>;
};

Args-Paren {
  (e.init) = (e.init);
  (e.init) (()) e.rest = <Args-Paren (e.init) e.rest>;
  (e.init ) ((e.expr)) e.rest = <Args-Paren (e.init (e.expr)) e.rest>;
  (e.init)() e.rest = <Args-Paren (e.init) e.rest>;
  (e.init) t.expr e.rest = <Args-Paren (e.init t.expr) e.rest>;
};

Optim-MAX (e.work) (e.res) e.rest, e.rest: {
  /*empty*/ =   {
    e.work : 0  =  { 	
      e.res: /*empty*/ =  0;
      <Neg-Sign e.res> :: s.sign, s.sign : {
        1 = 0;
        0 = (MAX (e.work) <Del-Neg e.res>); 
        };
      };
    e.work : /*empty*/ = <Neg-Optim e.res> :: e.arg, e.arg : {
      (e.max) = (e.max);
      e.max = (MAX e.max);
      };
    (MAX (e.work) <Neg-Optim e.res> ) ;
    };
  (t.item) e.args = {
    t.item : s.IntSymbol = e.work :  {
      /*empty*/ = <Optim-MAX (s.IntSymbol) (e.res) e.args>; 
      s.Int = {
        <">" (s.IntSymbol) (s.Int)> = 
          <Optim-MAX (s.IntSymbol) (e.res) e.args >;
        <Optim-MAX (s.Int) (e.res) e.args >;
        };
      };
    e.res : e.1 (t.item) e.2 = <Optim-MAX (e.work) (e.res) e.args>;
    <Optim-MAX (e.work) (e.res (t.item)) e.args>;
    };
};

Neg-Sign  
{
  /*empty*/ = 1;
  ((INFIX "-" (0) e.int)) e.rest = <Neg-Sign e.rest>;
  e.int =  0;
};

Del-Neg {
  /*empty*/ = /*empty*/;
  ((INFIX "-" (0) e.int)) e.rest = <Del-Neg e.rest>;
  t.int e.rest = t.int <Del-Neg e.rest>;
};

Neg-Optim e.int = <Neg-Sign e.int> :: s.sign, {
  s.sign : 1 = e.int;
  <Del-Neg e.int>;
};

Optim-MIN (e.work) (e.res) e.rest, e.rest: {
  /*empty*/ = e.work : {
    /*empty*/ = (MIN e.res);
    s.int = (MIN (s.int) e.res ) ;
    };
  (t.item) e.args,  t.item : {
    s.IntSymbol = e.work : {
      /*empty*/ = <Optim-MIN (s.IntSymbol) (e.res) e.args>;
      s.Int = 
        {
          <"<" (s.IntSymbol) (s.Int)> = 
            <Optim-MIN (s.IntSymbol) (e.res) e.args >;
          <Optim-MIN (s.Int) (e.res) e.args >;
        };
      };
    t.item = 
      {
        e.res : e.1 (t.item) e.2 = <Optim-MIN (e.work) (e.res) e.args>;
        <Optim-MIN (e.work) (e.res (t.item)) e.args>;
      };
    };
};

Optim-Add (s.res) (e.expr) e.expr-int,  e.expr-int  : {
  /*empty*/ = {
    e.expr :  /*empty*/ = s.res ;
    s.res : 0 = <Int-Paren e.expr>;
    (INFIX "+" ( s.res e.expr) ) ;
    }; 
  (0) e.rest = <Optim-Add (s.res) (e.expr) e.rest>;
  (s.Int) e.rest =  <Optim-Add  ( <"+" s.Int s.res>) (e.expr) e.rest>; 
  t.int e.rest = <Optim-Add (s.res) (e.expr t.int) e.rest>;
}; 

Optim-Minus {
  ( )(e.expr)(s.int) = /*empty*/;
  ( )(e.expr)(s.int) t.term-int e.rest = 
    <Optim-Minus (t.term-int)(e.expr)(s.int) e.rest>;
  ((e.first)) (e.expr) (s.int) e.expr-int  = e.expr-int : {
    /*empty*/ = {
      e.first  :  s.first-int  = {
        s.int : 0 = (INFIX "-" (s.first-int) e.expr);
        (INFIX "-" ( <"-" s.first-int s.int>) e.expr);
        };
      e.expr : /*empty*/ = {
        s.int : 0 = <Int-Paren e.first> ;
        (INFIX "-" (e.first) (s.int) );
        };
      s.int : 0 = (INFIX "-"  (e.first) e.expr);
      (INFIX "-"  (e.first) e.expr (s.int) );
      };
    e.first e.rest = <Optim-Minus ((0)) (e.expr)(s.int) e.rest>;
    (e.1 e.first e.2) e.rest = 
      <Optim-Minus ((0))(e.expr (e.1 e.2))(s.int) e.rest>; 
    (0) e.rest = <Optim-Minus ((e.first)) (e.expr)(s.int) e.rest>;
    (s.new) e.rest = <Optim-Minus ((e.first)) (e.expr)
      ( <"+" s.int s.new> ) e.rest>; 
    t.new e.rest = <Optim-Minus ((e.first)) (e.expr t.new)(s.int) e.rest>;
    }; 
};

Optim-Mult (s.res) (e.expr) e.expr-int,  e.expr-int  : {
  /*empty*/ = {
    e.expr :  /*empty*/ = s.res ;
    s.res : 1 = <Int-Paren e.expr> ;
    (INFIX "*" ( s.res) e.expr ) ;
    }; 
  (0) e.rest = 0 ;
  (1) e.rest = <Optim-Mult (s.res) (e.expr) e.rest >;
  (s.Int) e.rest =  <Optim-Mult  ( <"*" s.Int s.res>) (e.expr) e.rest>; 
  t.int e.rest = <Optim-Mult (s.res) (e.expr t.int) e.rest>;
}; 

Optim-Div  {
  /*empty*/ = /*empty*/;
  (0) e.expr = 0;
  t.int e.expr = <Optim-Mult (1) () e.expr> :: e.znam, e.znam: {
    1 = <Int-Paren t.int> ;
    1 e.rest = (INFIX "/" t.int e.rest  );
    e.znam = (INFIX "/" e.znam );
    };
}; 

Optim-Rem  {
  (0) e.int = 0;
  e.expr1 (0) e.expr2 = $error ("Int-operation Mod for zero");
  t.int t.int e.expr = 0;
  t.int e.expr1 (1) e.expr2 = 0; 
  (s.int1) (s.int2) e.expr = <Rem s.int1 s.int2> :: s.res, {
    s.res : 0 = 0;
    <Optim-Rem (s.res) e.expr >;
    };
  e.expr = (INFIX "%"  e.expr);
};
   
Optim-Cond (e.init) e.cond, e.cond: {
  /*empty*/ =  {
    e.init : /*empty*/ = (1);
    e.init : ((e.res)) = (e.res) ;
    e.init;
    };
  e.cond1 (0) e.cond2 = (0);
  e.cond1  (s.int)  e.cond2 = <Optim-Cond (e.init) e.cond1 e.cond2 >;
  t.cond-term e.rest = t.cond-term : {
    (CALL e.call) = <Optim-Cond (e.init (CALL e.call)) e.rest>;
    (SYMBOL? e.expr (e.pos)) = <Optim-Ref e.expr> :: e.expr,
      <Push> <Optim-Int e.pos> :: e.pos,
      <Optim-Cond (e.init (SYMBOL? e.expr (e.pos))) e.rest>;     
    (FLAT-SUBEXPR? e.expr (e.pos) (e.len)) = 
       <Optim-Ref e.expr> :: e.expr,
       <Push> <Optim-Int e.pos> :: e.pos,
       <Push> <Optim-Int e.len> :: e.len,
       <Optim-Cond (e.init (FLAT-SUBEXPR? e.expr 
         (e.pos)(e.len))) e.rest>;
    (EQ e.expr1 (e.expr2) (e.pos)) =
      <Optim-Ref e.expr1> :: e.expr1,
      <Optim-Ref e.expr2> :: e.expr2,
      <Push> <Optim-Int e.pos> :: e.pos,
      <Optim-Cond (e.init (EQ e.expr1 (e.expr2) (e.pos))) e.rest>;
    (FLAT-EQ e.expr1 (e.expr2) (e.pos)) = 
      <Optim-Ref e.expr1> :: e.expr1,
      <Optim-Ref e.expr2> :: e.expr2,
      <Push> <Optim-Int e.pos> :: e.pos,
      <Optim-Cond (e.init 
        (FLAT-EQ e.expr1 (e.expr2) (e.pos))) e.rest>;
    (CHECK-ITER t.var) = 
      <Optim-Cond (e.init (CHECK-ITER t.var)) e.rest>;
    (NOT e.cond-new) = <Optim-Cond () e.cond-new> :: e.res, 
      e.res: {
        0 = <Optim-Cond (e.init) e.rest>;
        1 = 0;
        e.res = <Optim-Cond (e.init (NOT e.res)) e.rest>;
        };
    (INFIX s.op e.args) =  {
      s.op : \{ "&&"; "||"; } = 
          <Optim-Log-Args e.args> :: e.args,
          <Optim-Cond-Log s.op e.args>;
      s.op : \{ "<"; ">"; "<="; ">="; "=="; "!="; } = 
        <Optim-Int-Args e.args> :: e.args,
          <Optim-Cond-Int s.op e.args>; 
      s.op : \{ "%"; "/";"*";"-";"+";} = 
         (<Push> <Optim-Int (INFIX s.op e.args)>);
      }  :: e.res,
      <Optim-Cond (e.init e.res) e.rest>; 
     (s.int) = ; 
     (e.expr-int) = <Optim-Cond (e.init 
       (<Push> <Optim-Int (e.expr-int)>)) e.rest>;     
   };
};

Optim-Log-Args  {
  /*empty*/ = /*empty*/;
  (s.int) e.rest = (s.int) <Optim-Log-Args e.rest>;
  (e.arg) e.rest = <Optim-Log-Expr e.arg> :: e.res, 
    <Args-Paren () e.res> <Optim-Log-Args e.rest>;
};

Optim-Cond-Log s.op e.res = 
// <Optim-Cond () e.args> :: e.res, 
//  {
{  e.res :  t.result = t.result;
  {
    s.op : "&&" = { 
      e.res : e.log1 0 e.log2 = (0);
      <AND-Args e.res> :: e.log, {
        e.log: /*empty*/ = (1);
        (INFIX "&&" e.log);
      };
    };
    s.op : "||" =
    {
      e.res : e.log1 1 e.log2 = (1);
      <OR-Args e.res> :: e.log, { 
        e.log : /*empty*/ = (0);
        e.log :  e.log1 s.int e.log2 = (1);
        (INFIX "||" e.log);
     };
    };
  };
}; 

AND-Args  {
  /*empty*/ = /*empty*/;
  s.log e.args = <AND-Args e.args>;
  t.log e.args = t.log <AND-Args e.args>;
};

OR-Args  {
  /*empty*/ = /*empty*/;
  (0)  e.args = <OR-Args e.args>;
  s.log e.args = (1);
  t.log e.args = t.log <OR-Args e.args>;
};

Optim-Cond-Int s.op e.args, {
  e.args : (s.1)  (s.2) = s.op : {
    "==" = {
      <"=" (s.1) (s.2) > = (1);
      (0);
      };
    "!=" = {
      <"/=" (s.1) (s.2) > = (1);
      (0);
      }; 
    "<" = { 
      <"<" (s.1) (s.2)> = (1);
      (0);
      };
    ">" = {
      <">" (s.1) (s.2)> = (1);
      (0);
      };
    ">=" = {
      <">=" (s.1) (s.2)> = (1);
      (0);
      };
    "<=" = {
      <"<=" (s.1) (s.2)> = (1);
      (0);
      };
    };
// e.args : (0)  (e.arg2) = s.op : {
//  "<=" = 1;
//  ">" = 0;
//  s.op = 	(INFIX s.op e.args);
//  };
// e.args : (e.arg1) (0) = s.op : {
//  "<" = 0;
//  ">=" = 1;
//  s.op = 	(INFIX s.op e.args);
//  };
  e.args : (e.arg1)(e.arg1) = s.op:{
    "==" = (1);
    "!=" = (0);
    "<=" = (1);
    ">=" = (1);
    "<" = (0);
    ">" = (0);
    };
  (INFIX s.op e.args);
};

Push /*empty*/ = <Store &Stack-Int (0) <? &Stack-Int> >;

Pop  /*empty*/ = 
  <? &Stack-Int> :: e.stack,
    e.stack : (s.flag e.int) e.rest,
    <Store &Stack-Int e.rest>,
    e.int : {
      /*empty*/ = ;
      0 = s.flag : {
        0 = 0;
        1 = ;
        };
      s.res = s.res;
};

Add-Stack-Int s.int = 
  <? &Stack-Int> :: e.stack,
    e.stack : (s.flag e.res) e.rest,
    e.res : {
      /*empty*/ = <Store &Stack-Int (s.flag s.int) e.rest>;
      s.old = <Store &Stack-Int (s.flag <"+" s.old s.int>) e.rest>;
      };

Add-Stack-Flag /*empty*/ =  
  <? &Stack-Int> :: e.stack,
    e.stack : (s.flag e.res) e.rest,
    <Store &Stack-Int (1 e.res) e.rest>;  	

Int-Paren  {
  /*empty*/ = /*empty*/;
  ((e.int)) e.tail = (e.int) <Int-Paren e.tail>;
  t.int  e.tail = t.int <Int-Paren e.tail>;	
};

Clear-Table {
  s.table = ;
  s.table (e.key) e.rest =  <Unbind s.table e.key>
    <Clear-Table s.table e.rest>;
};

Correct-Label  e.asail, e.asail: {
  /*empty*/ = /*empty*/;
  t.item e.rest = 
  t.item : {
    (IF (e.cond) e.body) =
      <Correct-Label e.body> :: e.body, 
      (IF (e.cond) e.body);
    (FOR (e.cont-label) (e.break-label) (e.cond) (e.step) e.body) =
      <Label-In-Table e.cont-label> :: e.cont-label,
      <Label-In-Table e.break-label> :: e.break-label, 
      <Correct-Label e.body> :: e.body,                             
      (FOR (e.cont-label) (e.break-label) (e.cond) (e.step) e.body);
    (LABEL (e.label) e.body) =
      <Label-In-Table e.label> :: e.maybe-empty, 
      <Correct-Label e.body> :: e.body,
      (LABEL (e.maybe-empty) e.body) ;
    (TRY e.body) = <Correct-Label e.body> :: e.body,
      (TRY e.body);
    (CATCH-ERROR e.body) =<Correct-Label e.body> :: e.body, 
      (CATCH-ERROR e.body);
    t.item = t.item ; 
    } :: e.cpp-item,
  e.cpp-item <Correct-Label e.rest>;
};

Label-In-Table {
  /*empty*/ = ;
  t.label = {
    <In-Table? &Used-Label  t.label> = t.label; ;
  };
};

Optim-Log-Expr {
/*empty*/ = /*empty*/ ;
t.term e.rest =  t.term : {
  (CALL e.call) = (CALL e.call) ;
  (SYMBOL? e.expr (e.pos)) = <Optim-Ref e.expr> :: e.expr,
    <Push> <Optim-Int e.pos> :: e.pos,
    (SYMBOL? e.expr (e.pos));     
  (FLAT-SUBEXPR? e.expr (e.pos) (e.len)) = 
    <Optim-Ref e.expr> :: e.expr,
    <Push> <Optim-Int e.pos> :: e.pos,
    <Push> <Optim-Int e.len> :: e.len,
    (FLAT-SUBEXPR? e.expr (e.pos)(e.len));
  (EQ e.expr1 (e.expr2) (e.pos) ) =
    <Optim-Ref e.expr1> :: e.expr1,
    <Optim-Ref e.expr2> :: e.expr2,
    <Push> <Optim-Int e.pos> :: e.pos,
    (EQ e.expr1 (e.expr2) (e.pos));
  (FLAT-EQ e.expr1 (e.expr2) (e.pos)) = 
    <Optim-Ref e.expr1> :: e.expr1,
    <Optim-Ref e.expr2> :: e.expr2,
    <Push> <Optim-Int e.pos> :: e.pos,
    (FLAT-EQ e.expr1 (e.expr2) (e.pos));
  (CHECK-ITER t.var) = (CHECK-ITER t.var);
  (NOT e.cond-new) = <Optim-Cond () e.cond-new> :: e.res, 
     e.res: {
       0 = /*empty*/;
       1 = (0) ;
       e.res = (NOT e.res) ;
     };
   (INFIX s.op e.args) =  {
     s.op : \{ "&&"; "||"; } = 
       <Optim-Log-Args e.args> :: e.args,
       <Optim-Cond-Log s.op e.args>;
     s.op : \{ "<"; ">"; "<="; ">="; "=="; "!="; } = 
       <Optim-Int-Args e.args> :: e.args,
       <Optim-Cond-Int s.op e.args>;
     s.op : \{ "%"; "/";"*";"-";"+";} = 
       (<Push> <Optim-Int (INFIX s.op e.args)>);
     };
  (s.int) = /*empty*/; 
  (e.expr-int) = (<Push> <Optim-Int (e.expr-int)>);
  } :: e.res,
    e.res <Optim-Log-Expr e.rest>;
};