/*
~function~

*/
GDIJKSTRA_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" GD"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
MINPATHCOST2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" GD"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
GBIDIJKSTRA_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" GD"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
MTMINPATHCOSTS2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" GD"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
D_SEND_SHUFFLE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DSHUFFLE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DRELATION"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DSHUFFLE2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DRELATION"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DSHUFFLE1_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DRELATION"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DLOOP_OLD_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"element");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DLOOPA_OLD_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"first");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"second");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" DELEMENT2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DTIE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"first");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"second");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" DELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PARTITIONDMAP_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" PDTS"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DMAPPDMAP_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DPD4"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
FDISTRIBUTE2TES_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DISTRIBUTE2TES_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
OPTICSF_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"argument1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"argument2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
OPTICSTF_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"argument1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"argument2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
FILTERV_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TVS2T"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
FILTERNP_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
EXTENDV_fun:   naming EXTENDV_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming EXTENDV_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | EXTENDV_fun_1   {$$ = $1;} 
      | EXTENDV_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
EXTENDV_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TVS2T"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
EXTENDV_funlist: EXTENDV_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
EXTENDV_funlist_1  : EXTENDV_fun{$$ = $1;}
     | EXTENDV_funlist_1 ',' EXTENDV_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
PROJECTEXTENDV_fun:   naming PROJECTEXTENDV_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming PROJECTEXTENDV_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | PROJECTEXTENDV_fun_1   {$$ = $1;} 
      | PROJECTEXTENDV_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
PROJECTEXTENDV_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TVS2T"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
PROJECTEXTENDV_funlist: PROJECTEXTENDV_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
PROJECTEXTENDV_funlist_1  : PROJECTEXTENDV_fun{$$ = $1;}
     | PROJECTEXTENDV_funlist_1 ',' PROJECTEXTENDV_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
EXTENDNP_fun:   naming EXTENDNP_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming EXTENDNP_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | EXTENDNP_fun_1   {$$ = $1;} 
      | EXTENDNP_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
EXTENDNP_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
EXTENDNP_funlist: EXTENDNP_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
EXTENDNP_funlist_1  : EXTENDNP_fun{$$ = $1;}
     | EXTENDNP_funlist_1 ',' EXTENDNP_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
PROJECTEXTENDNP_fun:   naming PROJECTEXTENDNP_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming PROJECTEXTENDNP_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | PROJECTEXTENDNP_fun_1   {$$ = $1;} 
      | PROJECTEXTENDNP_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
PROJECTEXTENDNP_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
PROJECTEXTENDNP_funlist: PROJECTEXTENDNP_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
PROJECTEXTENDNP_funlist_1  : PROJECTEXTENDNP_fun{$$ = $1;}
     | PROJECTEXTENDNP_funlist_1 ',' PROJECTEXTENDNP_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
APPLYPREDICATE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"blockentry");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" BLOCKENTRY"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
FILTER_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
CFILTER_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
CAND_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"block");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ANY"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
COR_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"block");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ANY"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
WITHIN_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"const1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ANY"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
WITHIN2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"const1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"const2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ANY"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ANY2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
WHILEDO_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"const1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ANY"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
FUNSEQ1_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARGEF1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
FUNSEQ2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARGEF1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARGEF2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
FUNSEQ3_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARGEF1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARGEF2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARGEF3"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) ))));
     cleanVariables(3); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
FUNSEQ4_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem4");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARGEF1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARGEF2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARGEF3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" ARGEF4"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) ))));
     cleanVariables(4); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
FUNSEQ5_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem4");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem5");
     sprintf(params[5], "%s_%d",paramname,paramno);
     p = pair<int,string>(5, params[5]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARGEF1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARGEF2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARGEF3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" ARGEF4"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[5]),
     NestedText::Concat( NestedText::AtomC(" ARGEF5"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) ))));
     cleanVariables(5); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
FUNSEQ6_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem4");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem5");
     sprintf(params[5], "%s_%d",paramname,paramno);
     p = pair<int,string>(5, params[5]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem6");
     sprintf(params[6], "%s_%d",paramname,paramno);
     p = pair<int,string>(6, params[6]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARGEF1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARGEF2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARGEF3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" ARGEF4"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[5]),
     NestedText::Concat( NestedText::AtomC(" ARGEF5"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[6]),
     NestedText::Concat( NestedText::AtomC(" ARGEF6"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) ))));
     cleanVariables(6); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DDISTRIBUTE4_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
FDISTRIBUTE7_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DLOOP_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"darrayelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DLOOP2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DARRAYELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" DARRAYELEM2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DMAP_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"dmapelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmapslotno");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PDMAP_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"dmapelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmapslotno");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DMAP2n_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmapslotno");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) ))));
     cleanVariables(3); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DMAP2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmslotno");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) ))));
     cleanVariables(3); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DMAP3_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmslotno");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) ))));
     cleanVariables(4); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DMAP4_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem4");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmslotno");
     sprintf(params[5], "%s_%d",paramname,paramno);
     p = pair<int,string>(5, params[5]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[5]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) ))));
     cleanVariables(5); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DMAP5_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem4");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem5i");
     sprintf(params[5], "%s_%d",paramname,paramno);
     p = pair<int,string>(5, params[5]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmslotno");
     sprintf(params[6], "%s_%d",paramname,paramno);
     p = pair<int,string>(6, params[6]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[5]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[6]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) ))));
     cleanVariables(6); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DMAP6_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem4");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem5");
     sprintf(params[5], "%s_%d",paramname,paramno);
     p = pair<int,string>(5, params[5]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem6");
     sprintf(params[6], "%s_%d",paramname,paramno);
     p = pair<int,string>(6, params[6]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmslotno");
     sprintf(params[7], "%s_%d",paramname,paramno);
     p = pair<int,string>(7, params[7]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[5]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[6]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG6"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[7]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) )))) ))));
     cleanVariables(7); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DMAP7_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem4");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem5");
     sprintf(params[5], "%s_%d",paramname,paramno);
     p = pair<int,string>(5, params[5]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem6");
     sprintf(params[6], "%s_%d",paramname,paramno);
     p = pair<int,string>(6, params[6]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem7");
     sprintf(params[7], "%s_%d",paramname,paramno);
     p = pair<int,string>(7, params[7]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmslotno");
     sprintf(params[8], "%s_%d",paramname,paramno);
     p = pair<int,string>(8, params[8]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[5]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[6]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG6"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[7]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG7"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[8]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) )))) )))) ))));
     cleanVariables(8); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DMAP8_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem4");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem5");
     sprintf(params[5], "%s_%d",paramname,paramno);
     p = pair<int,string>(5, params[5]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem6");
     sprintf(params[6], "%s_%d",paramname,paramno);
     p = pair<int,string>(6, params[6]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem7");
     sprintf(params[7], "%s_%d",paramname,paramno);
     p = pair<int,string>(7, params[7]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem8");
     sprintf(params[8], "%s_%d",paramname,paramno);
     p = pair<int,string>(8, params[8]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmslotno");
     sprintf(params[9], "%s_%d",paramname,paramno);
     p = pair<int,string>(9, params[9]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[5]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[6]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG6"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[7]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG7"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[8]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG8"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[9]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) )))) )))) )))) ))));
     cleanVariables(9); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PDMAP2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmslotno");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) ))));
     cleanVariables(3); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PDMAP3_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmslotno");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) ))));
     cleanVariables(4); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PDMAP4_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem4i");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmslotno");
     sprintf(params[5], "%s_%d",paramname,paramno);
     p = pair<int,string>(5, params[5]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[5]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) ))));
     cleanVariables(5); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PDMAP5_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem4");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem5i");
     sprintf(params[5], "%s_%d",paramname,paramno);
     p = pair<int,string>(5, params[5]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmslotno");
     sprintf(params[6], "%s_%d",paramname,paramno);
     p = pair<int,string>(6, params[6]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[5]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG6"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[6]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) ))));
     cleanVariables(6); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PDMAP6_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem4");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem5");
     sprintf(params[5], "%s_%d",paramname,paramno);
     p = pair<int,string>(5, params[5]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem6");
     sprintf(params[6], "%s_%d",paramname,paramno);
     p = pair<int,string>(6, params[6]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmslotno");
     sprintf(params[7], "%s_%d",paramname,paramno);
     p = pair<int,string>(7, params[7]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[5]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG6"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[6]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG7"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[7]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) )))) ))));
     cleanVariables(7); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PDMAP7_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem4");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem5");
     sprintf(params[5], "%s_%d",paramname,paramno);
     p = pair<int,string>(5, params[5]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem6");
     sprintf(params[6], "%s_%d",paramname,paramno);
     p = pair<int,string>(6, params[6]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem7");
     sprintf(params[7], "%s_%d",paramname,paramno);
     p = pair<int,string>(7, params[7]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmslotno");
     sprintf(params[8], "%s_%d",paramname,paramno);
     p = pair<int,string>(8, params[8]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[5]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG6"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[6]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG7"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[7]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG8"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[8]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) )))) )))) ))));
     cleanVariables(8); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PDMAP8_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem4");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem5");
     sprintf(params[5], "%s_%d",paramname,paramno);
     p = pair<int,string>(5, params[5]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem6");
     sprintf(params[6], "%s_%d",paramname,paramno);
     p = pair<int,string>(6, params[6]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem7");
     sprintf(params[7], "%s_%d",paramname,paramno);
     p = pair<int,string>(7, params[7]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem8");
     sprintf(params[8], "%s_%d",paramname,paramno);
     p = pair<int,string>(8, params[8]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"dmslotno");
     sprintf(params[9], "%s_%d",paramname,paramno);
     p = pair<int,string>(9, params[9]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[5]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG6"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[6]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG7"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[7]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG8"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[8]),
     NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG9"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[9]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) )))) )))) )))) ))));
     cleanVariables(9); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DFDISTRIBUTE4_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PARTITION_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" SUBSUBTYPE1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PARTITIONF_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" FFR"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" FFR"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
AREDUCE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" AREDUCEARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
AREDUCE2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" AREDUCEARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" AREDUCEARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
AREDUCE2F_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" AREDUCEARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" AREDUCEARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DPRODUCT_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DPRODUCTARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" DPRODUCTARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DDISTRIBUTE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DFDISTRIBUTE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PARTITION8LOCAL_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PARTITIONF8_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" P8TM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
LOOPJOINREL_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
CONSTGRAPH_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
CONSTGRAPHPOINTS_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
EXISTS_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
FORALL_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PARAJOIN_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"stream1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"stream2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPSTREAM2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" TUPSTREAM3"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
HADOOPJOIN_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"stream1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"stream2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ANY"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ANY2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
MUPDATE_fun:   naming MUPDATE_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming MUPDATE_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | MUPDATE_fun_1   {$$ = $1;} 
      | MUPDATE_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
MUPDATE_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" MTUPLE2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
MUPDATE_funlist: MUPDATE_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
MUPDATE_funlist_1  : MUPDATE_fun{$$ = $1;}
     | MUPDATE_funlist_1 ',' MUPDATE_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
MUPDATESAVE_fun:   naming MUPDATESAVE_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming MUPDATESAVE_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | MUPDATESAVE_fun_1   {$$ = $1;} 
      | MUPDATESAVE_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
MUPDATESAVE_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" MTUPLE2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
MUPDATESAVE_funlist: MUPDATESAVE_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
MUPDATESAVE_funlist_1  : MUPDATESAVE_fun{$$ = $1;}
     | MUPDATESAVE_funlist_1 ',' MUPDATESAVE_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
MUPDATEBYID_fun:   naming MUPDATEBYID_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming MUPDATEBYID_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | MUPDATEBYID_fun_1   {$$ = $1;} 
      | MUPDATEBYID_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
MUPDATEBYID_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" MTUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
MUPDATEBYID_funlist: MUPDATEBYID_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
MUPDATEBYID_funlist_1  : MUPDATEBYID_fun{$$ = $1;}
     | MUPDATEBYID_funlist_1 ',' MUPDATEBYID_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
MUPDATEDIRECT2_fun:   naming MUPDATEDIRECT2_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming MUPDATEDIRECT2_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | MUPDATEDIRECT2_fun_1   {$$ = $1;} 
      | MUPDATEDIRECT2_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
MUPDATEDIRECT2_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"tuple2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" MTUPLE2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
MUPDATEDIRECT2_funlist: MUPDATEDIRECT2_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
MUPDATEDIRECT2_funlist_1  : MUPDATEDIRECT2_fun{$$ = $1;}
     | MUPDATEDIRECT2_funlist_1 ',' MUPDATEDIRECT2_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
MOSHORTESTPATHD_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" MTUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
MOSHORTESTPATHA_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" MTUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
MGSHORTESTPATHD_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" MTUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
MGSHORTESTPATHA_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" MTUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
MPQREORDER_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" MTUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
MPQREORDERUPDATE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" MTUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
CREATEMGRAPH2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
CREATEMGRAPH2FLOB_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
MG2INSERTORIG_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
MEMGROUPBY_fun:   naming MEMGROUPBY_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming MEMGROUPBY_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | MEMGROUPBY_fun_1   {$$ = $1;} 
      | MEMGROUPBY_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
MEMGROUPBY_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"mgroup");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" MGROUP"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
MEMGROUPBY_funlist: MEMGROUPBY_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
MEMGROUPBY_funlist_1  : MEMGROUPBY_fun{$$ = $1;}
     | MEMGROUPBY_funlist_1 ',' MEMGROUPBY_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
PUSE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"element");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" PSTREAM1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
PJOIN2_fun:   naming PJOIN2_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming PJOIN2_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | PJOIN2_fun_1   {$$ = $1;} 
      | PJOIN2_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
PJOIN2_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"left");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"right");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" PSTREAM1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" PSTREAM2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
PJOIN2_funlist: PJOIN2_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
PJOIN2_funlist_1  : PJOIN2_fun{$$ = $1;}
     | PJOIN2_funlist_1 ',' PJOIN2_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
PJOIN1_fun:   naming PJOIN1_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming PJOIN1_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | PJOIN1_fun_1   {$$ = $1;} 
      | PJOIN1_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
PJOIN1_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"left");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"right");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" PSTREAM1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ANY2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
PJOIN1_funlist: PJOIN1_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
PJOIN1_funlist_1  : PJOIN1_fun{$$ = $1;}
     | PJOIN1_funlist_1 ',' PJOIN1_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
SORTARRAY_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"element");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
TIE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"first");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"second");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
CUMULATE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"first");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"second");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
LOOP_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"element");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
LOOPA_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"first");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"second");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
LOOPB_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"first");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"second");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
LOOPSWITCH_fun:   naming LOOPSWITCH_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming LOOPSWITCH_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | LOOPSWITCH_fun_1   {$$ = $1;} 
      | LOOPSWITCH_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
LOOPSWITCH_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"element");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
LOOPSWITCH_funlist: LOOPSWITCH_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
LOOPSWITCH_funlist_1  : LOOPSWITCH_fun{$$ = $1;}
     | LOOPSWITCH_funlist_1 ',' LOOPSWITCH_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
LOOPSWITCHA_fun:   naming LOOPSWITCHA_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming LOOPSWITCHA_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | LOOPSWITCHA_fun_1   {$$ = $1;} 
      | LOOPSWITCHA_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
LOOPSWITCHA_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"first");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"second");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
LOOPSWITCHA_funlist: LOOPSWITCHA_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
LOOPSWITCHA_funlist_1  : LOOPSWITCHA_fun{$$ = $1;}
     | LOOPSWITCHA_funlist_1 ',' LOOPSWITCHA_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
LOOPSWITCHB_fun:   naming LOOPSWITCHB_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming LOOPSWITCHB_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | LOOPSWITCHB_fun_1   {$$ = $1;} 
      | LOOPSWITCHB_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
LOOPSWITCHB_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"first");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"second");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
LOOPSWITCHB_funlist: LOOPSWITCHB_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
LOOPSWITCHB_funlist_1  : LOOPSWITCHB_fun{$$ = $1;}
     | LOOPSWITCHB_funlist_1 ',' LOOPSWITCHB_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
LOOPSELECT_fun:   naming LOOPSELECT_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming LOOPSELECT_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | LOOPSELECT_fun_1   {$$ = $1;} 
      | LOOPSELECT_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
LOOPSELECT_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"element");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
LOOPSELECT_funlist: LOOPSELECT_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
LOOPSELECT_funlist_1  : LOOPSELECT_fun{$$ = $1;}
     | LOOPSELECT_funlist_1 ',' LOOPSELECT_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
LOOPSELECTA_fun:   naming LOOPSELECTA_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming LOOPSELECTA_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | LOOPSELECTA_fun_1   {$$ = $1;} 
      | LOOPSELECTA_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
LOOPSELECTA_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"first");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"second");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
LOOPSELECTA_funlist: LOOPSELECTA_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
LOOPSELECTA_funlist_1  : LOOPSELECTA_fun{$$ = $1;}
     | LOOPSELECTA_funlist_1 ',' LOOPSELECTA_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
LOOPSELECTB_fun:   naming LOOPSELECTB_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming LOOPSELECTB_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | LOOPSELECTB_fun_1   {$$ = $1;} 
      | LOOPSELECTB_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
LOOPSELECTB_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"first");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"second");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
LOOPSELECTB_funlist: LOOPSELECTB_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
LOOPSELECTB_funlist_1  : LOOPSELECTB_fun{$$ = $1;}
     | LOOPSELECTB_funlist_1 ',' LOOPSELECTB_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
PARTJOIN_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"first");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"second");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
PARTJOINSWITCH_fun:   naming PARTJOINSWITCH_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming PARTJOINSWITCH_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | PARTJOINSWITCH_fun_1   {$$ = $1;} 
      | PARTJOINSWITCH_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
PARTJOINSWITCH_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"first");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"second");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
PARTJOINSWITCH_funlist: PARTJOINSWITCH_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
PARTJOINSWITCH_funlist_1  : PARTJOINSWITCH_fun{$$ = $1;}
     | PARTJOINSWITCH_funlist_1 ',' PARTJOINSWITCH_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
PARTJOINSELECT_fun:   naming PARTJOINSELECT_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming PARTJOINSELECT_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | PARTJOINSELECT_fun_1   {$$ = $1;} 
      | PARTJOINSELECT_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
PARTJOINSELECT_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"first");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"second");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
PARTJOINSELECT_funlist: PARTJOINSELECT_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
PARTJOINSELECT_funlist_1  : PARTJOINSELECT_fun{$$ = $1;}
     | PARTJOINSELECT_funlist_1 ',' PARTJOINSELECT_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
EXTEND_fun:   naming EXTEND_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming EXTEND_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | EXTEND_fun_1   {$$ = $1;} 
      | EXTEND_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
EXTEND_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
EXTEND_funlist: EXTEND_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
EXTEND_funlist_1  : EXTEND_fun{$$ = $1;}
     | EXTEND_funlist_1 ',' EXTEND_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
PARAJOIN2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"stream1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"stream2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ANY"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ANY2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DRELFILTER_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DRELFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
DRELEXTEND_fun:   naming DRELEXTEND_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming DRELEXTEND_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | DRELEXTEND_fun_1   {$$ = $1;} 
      | DRELEXTEND_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
DRELEXTEND_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DRELFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
DRELEXTEND_funlist: DRELEXTEND_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
DRELEXTEND_funlist_1  : DRELEXTEND_fun{$$ = $1;}
     | DRELEXTEND_funlist_1 ',' DRELEXTEND_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
DRELPROJECTEXTEND_fun:   naming DRELPROJECTEXTEND_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming DRELPROJECTEXTEND_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | DRELPROJECTEXTEND_fun_1   {$$ = $1;} 
      | DRELPROJECTEXTEND_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
DRELPROJECTEXTEND_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DRELFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
DRELPROJECTEXTEND_funlist: DRELPROJECTEXTEND_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
DRELPROJECTEXTEND_funlist_1  : DRELPROJECTEXTEND_fun{$$ = $1;}
     | DRELPROJECTEXTEND_funlist_1 ',' DRELPROJECTEXTEND_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
DRELLGROUPBY_fun:   naming DRELLGROUPBY_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming DRELLGROUPBY_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | DRELLGROUPBY_fun_1   {$$ = $1;} 
      | DRELLGROUPBY_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
DRELLGROUPBY_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DRELRELFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
DRELLGROUPBY_funlist: DRELLGROUPBY_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
DRELLGROUPBY_funlist_1  : DRELLGROUPBY_fun{$$ = $1;}
     | DRELLGROUPBY_funlist_1 ',' DRELLGROUPBY_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
DRELGROUPBY_fun:   naming DRELGROUPBY_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming DRELGROUPBY_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | DRELGROUPBY_fun_1   {$$ = $1;} 
      | DRELGROUPBY_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
DRELGROUPBY_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DRELRELFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
DRELGROUPBY_funlist: DRELGROUPBY_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
DRELGROUPBY_funlist_1  : DRELGROUPBY_fun{$$ = $1;}
     | DRELGROUPBY_funlist_1 ',' DRELGROUPBY_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
DRELUPDATE_fun:   naming DRELUPDATE_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming DRELUPDATE_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | DRELUPDATE_fun_1   {$$ = $1;} 
      | DRELUPDATE_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
DRELUPDATE_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DRELFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
DRELUPDATE_funlist: DRELUPDATE_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
DRELUPDATE_funlist_1  : DRELUPDATE_fun{$$ = $1;}
     | DRELUPDATE_funlist_1 ',' DRELUPDATE_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
DRELUPDATEBYID_fun:   naming DRELUPDATEBYID_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming DRELUPDATEBYID_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | DRELUPDATEBYID_fun_1   {$$ = $1;} 
      | DRELUPDATEBYID_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
DRELUPDATEBYID_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" SUBSUBTYPE1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" DRELFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
DRELUPDATEBYID_funlist: DRELUPDATEBYID_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
DRELUPDATEBYID_funlist_1  : DRELUPDATEBYID_fun{$$ = $1;}
     | DRELUPDATEBYID_funlist_1 ',' DRELUPDATEBYID_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
DRELFILTERADDID_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DRELFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DRELFILTERDELETE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DRELFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
DRELFILTERUPDATE_fun:   naming DRELFILTERUPDATE_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming DRELFILTERUPDATE_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | DRELFILTERUPDATE_fun_1   {$$ = $1;} 
      | DRELFILTERUPDATE_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
DRELFILTERUPDATE_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DRELFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
DRELFILTERUPDATE_funlist: DRELFILTERUPDATE_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
DRELFILTERUPDATE_funlist_1  : DRELFILTERUPDATE_fun{$$ = $1;}
     | DRELFILTERUPDATE_funlist_1 ',' DRELFILTERUPDATE_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
DBSCANF_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"argument1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"argument2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DBSCANTF_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"streamelem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PFILTERS_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
PEXTEND_fun:   naming PEXTEND_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming PEXTEND_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | PEXTEND_fun_1   {$$ = $1;} 
      | PEXTEND_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
PEXTEND_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
PEXTEND_funlist: PEXTEND_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
PEXTEND_funlist_1  : PEXTEND_fun{$$ = $1;}
     | PEXTEND_funlist_1 ',' PEXTEND_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
PEXTENDSTREAM_fun:   naming PEXTENDSTREAM_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming PEXTENDSTREAM_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | PEXTENDSTREAM_fun_1   {$$ = $1;} 
      | PEXTENDSTREAM_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
PEXTENDSTREAM_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
PEXTENDSTREAM_funlist: PEXTENDSTREAM_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
PEXTENDSTREAM_funlist_1  : PEXTENDSTREAM_fun{$$ = $1;}
     | PEXTENDSTREAM_funlist_1 ',' PEXTENDSTREAM_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
PLOOPSEL_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PLOOPJOIN_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PAGGREGATE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"arg1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"arg2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" PAGGRT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" PAGGRT"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PAGGREGATEB_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"arg1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"arg2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" PAGGRT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" PAGGRT"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
AGGREGATES_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"streamelem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
USE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
USE2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"streamelem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
TS_fun:   naming TS_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming TS_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | TS_fun_1   {$$ = $1;} 
      | TS_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
TS_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
TS_funlist: TS_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
TS_funlist_1  : TS_fun{$$ = $1;}
     | TS_funlist_1 ',' TS_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
AS_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
streamfun_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
prog_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
SYNC_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
SideEffect_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"countelem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"streamelem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
OSHORTESTPATHD_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
OSHORTESTPATHA_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
READ2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DBSARG"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
READ3_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DBRARG"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
RDERIVE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" RELARG"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
READ3_1_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DBRARG"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" DBIARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
READ3_2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" DBRARG"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" DBIARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" DBIARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) ))));
     cleanVariables(3); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
FILTERX_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
UPDATESEARCH_fun:   naming UPDATESEARCH_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming UPDATESEARCH_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | UPDATESEARCH_fun_1   {$$ = $1;} 
      | UPDATESEARCH_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
UPDATESEARCH_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
UPDATESEARCH_funlist: UPDATESEARCH_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
UPDATESEARCH_funlist_1  : UPDATESEARCH_fun{$$ = $1;}
     | UPDATESEARCH_funlist_1 ',' UPDATESEARCH_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
UPDATEDIRECT_fun:   naming UPDATEDIRECT_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming UPDATEDIRECT_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | UPDATEDIRECT_fun_1   {$$ = $1;} 
      | UPDATEDIRECT_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
UPDATEDIRECT_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
UPDATEDIRECT_funlist: UPDATEDIRECT_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
UPDATEDIRECT_funlist_1  : UPDATEDIRECT_fun{$$ = $1;}
     | UPDATEDIRECT_funlist_1 ',' UPDATEDIRECT_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
UPDATEDIRECT2_fun:   naming UPDATEDIRECT2_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming UPDATEDIRECT2_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | UPDATEDIRECT2_fun_1   {$$ = $1;} 
      | UPDATEDIRECT2_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
UPDATEDIRECT2_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"tuple2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" TUPLE2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
UPDATEDIRECT2_funlist: UPDATEDIRECT2_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
UPDATEDIRECT2_funlist_1  : UPDATEDIRECT2_fun{$$ = $1;}
     | UPDATEDIRECT2_funlist_1 ',' UPDATEDIRECT2_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
UPDATEBYID2_fun:   naming UPDATEBYID2_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming UPDATEBYID2_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | UPDATEBYID2_fun_1   {$$ = $1;} 
      | UPDATEBYID2_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
UPDATEBYID2_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"tuple2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" TUPLE2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
UPDATEBYID2_funlist: UPDATEBYID2_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
UPDATEBYID2_funlist_1  : UPDATEBYID2_fun{$$ = $1;}
     | UPDATEBYID2_funlist_1 ',' UPDATEBYID2_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
UPDATESEARCHSAVE_fun:   naming UPDATESEARCHSAVE_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming UPDATESEARCHSAVE_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | UPDATESEARCHSAVE_fun_1   {$$ = $1;} 
      | UPDATESEARCHSAVE_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
UPDATESEARCHSAVE_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
UPDATESEARCHSAVE_funlist: UPDATESEARCHSAVE_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
UPDATESEARCHSAVE_funlist_1  : UPDATESEARCHSAVE_fun{$$ = $1;}
     | UPDATESEARCHSAVE_funlist_1 ',' UPDATESEARCHSAVE_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
UPDATEDIRECTSAVE_fun:   naming UPDATEDIRECTSAVE_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming UPDATEDIRECTSAVE_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | UPDATEDIRECTSAVE_fun_1   {$$ = $1;} 
      | UPDATEDIRECTSAVE_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
UPDATEDIRECTSAVE_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
UPDATEDIRECTSAVE_funlist: UPDATEDIRECTSAVE_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
UPDATEDIRECTSAVE_funlist_1  : UPDATEDIRECTSAVE_fun{$$ = $1;}
     | UPDATEDIRECTSAVE_funlist_1 ',' UPDATEDIRECTSAVE_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
UPDATEBYID_fun:   naming UPDATEBYID_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming UPDATEBYID_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | UPDATEBYID_fun_1   {$$ = $1;} 
      | UPDATEBYID_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
UPDATEBYID_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
UPDATEBYID_funlist: UPDATEBYID_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
UPDATEBYID_funlist_1  : UPDATEBYID_fun{$$ = $1;}
     | UPDATEBYID_funlist_1 ',' UPDATEBYID_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
FILTERINSERT_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
CPROJECTEXTEND_fun:   naming CPROJECTEXTEND_fun_1
      {$$ = NestedText::Concat(       (USE_AUTO_BUFFER?NestedText::AtomC("( ! (")                      :NestedText::AtomC("(")), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            (USE_AUTO_BUFFER?NestedText::AtomC("))")                            :NestedText::AtomC(")"))   ))));} 
    |   naming CPROJECTEXTEND_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(       (USE_AUTO_BUFFER?NestedText::AtomC("( ! (")                      :NestedText::AtomC("(")), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            (USE_AUTO_BUFFER?NestedText::AtomC("))")                            :NestedText::AtomC(")"))   ))))));} 
      | CPROJECTEXTEND_fun_1   {$$ = $1;} 
      | CPROJECTEXTEND_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
CPROJECTEXTEND_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
CPROJECTEXTEND_funlist: CPROJECTEXTEND_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
CPROJECTEXTEND_funlist_1  : CPROJECTEXTEND_fun{$$ = $1;}
     | CPROJECTEXTEND_funlist_1 ',' CPROJECTEXTEND_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
MAP_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"element");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" CELL1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
MAP2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" CELL1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" CELL2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
MATCHGRID_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"element");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" CELLS"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
REPLACEELEM_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
GROUPBY2_fun:   naming GROUPBY2_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming GROUPBY2_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | GROUPBY2_fun_1   {$$ = $1;} 
      | GROUPBY2_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
GROUPBY2_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
GROUPBY2_funlist: GROUPBY2_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
GROUPBY2_funlist_1  : GROUPBY2_fun{$$ = $1;}
     | GROUPBY2_funlist_1 ',' GROUPBY2_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
HADOOPMAP_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"lobject1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TPARA"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
HADOOPREDUCE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"lobject1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TPARA"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
HADOOPREDUCE2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"lobject1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"lobject2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TPARA"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" TPARA2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
HADOOPMAP2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"lobject1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"lobject2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TPARA"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" TPARA2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
GPATTERN_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
CROSSPATTERN_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
MTHREADEDFILTER_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
CANCEL_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
PROJECTEXTEND_fun:   naming PROJECTEXTEND_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming PROJECTEXTEND_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | PROJECTEXTEND_fun_1   {$$ = $1;} 
      | PROJECTEXTEND_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
PROJECTEXTEND_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
PROJECTEXTEND_funlist: PROJECTEXTEND_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
PROJECTEXTEND_funlist_1  : PROJECTEXTEND_fun{$$ = $1;}
     | PROJECTEXTEND_funlist_1 ',' PROJECTEXTEND_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
EXTENDSTREAM_fun:   naming EXTENDSTREAM_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming EXTENDSTREAM_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | EXTENDSTREAM_fun_1   {$$ = $1;} 
      | EXTENDSTREAM_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
EXTENDSTREAM_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
EXTENDSTREAM_funlist: EXTENDSTREAM_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
EXTENDSTREAM_funlist_1  : EXTENDSTREAM_fun{$$ = $1;}
     | EXTENDSTREAM_funlist_1 ',' EXTENDSTREAM_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
PROJECTEXTENDSTREAM_fun:   naming PROJECTEXTENDSTREAM_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming PROJECTEXTENDSTREAM_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | PROJECTEXTENDSTREAM_fun_1   {$$ = $1;} 
      | PROJECTEXTENDSTREAM_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
PROJECTEXTENDSTREAM_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
PROJECTEXTENDSTREAM_funlist: PROJECTEXTENDSTREAM_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
PROJECTEXTENDSTREAM_funlist_1  : PROJECTEXTENDSTREAM_fun{$$ = $1;}
     | PROJECTEXTENDSTREAM_funlist_1 ',' PROJECTEXTENDSTREAM_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
GROUPBY_fun:   naming GROUPBY_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming GROUPBY_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | GROUPBY_fun_1   {$$ = $1;} 
      | GROUPBY_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
GROUPBY_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"group");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" GROUP"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
GROUPBY_funlist: GROUPBY_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
GROUPBY_funlist_1  : GROUPBY_fun{$$ = $1;}
     | GROUPBY_funlist_1 ',' GROUPBY_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
SLIDINGWINDOW_fun:   naming SLIDINGWINDOW_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming SLIDINGWINDOW_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | SLIDINGWINDOW_fun_1   {$$ = $1;} 
      | SLIDINGWINDOW_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
SLIDINGWINDOW_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"group");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" GROUP"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
SLIDINGWINDOW_funlist: SLIDINGWINDOW_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
SLIDINGWINDOW_funlist_1  : SLIDINGWINDOW_fun{$$ = $1;}
     | SLIDINGWINDOW_funlist_1 ',' SLIDINGWINDOW_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
LOOPJOIN_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
LOOPSEL_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
AGGREGATE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"argument1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"argument2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
AGGREGATEB_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"argument1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"argument2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
SYMMJOIN_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"lefttuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"righttuple");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" TUPLE2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
SYMMOUTERJOIN_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"lefttuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"righttuple");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" TUPLE2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
SYMMPRODUCTEXTEND_fun:   naming SYMMPRODUCTEXTEND_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming SYMMPRODUCTEXTEND_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | SYMMPRODUCTEXTEND_fun_1   {$$ = $1;} 
      | SYMMPRODUCTEXTEND_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
SYMMPRODUCTEXTEND_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"lefttuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"righttuple");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" TUPLE2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
SYMMPRODUCTEXTEND_funlist: SYMMPRODUCTEXTEND_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
SYMMPRODUCTEXTEND_funlist_1  : SYMMPRODUCTEXTEND_fun{$$ = $1;}
     | SYMMPRODUCTEXTEND_funlist_1 ',' SYMMPRODUCTEXTEND_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
EXTEND_LAST_fun:   naming EXTEND_LAST_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming EXTEND_LAST_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | EXTEND_LAST_fun_1   {$$ = $1;} 
      | EXTEND_LAST_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
EXTEND_LAST_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"currenttuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"lasttuple");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
EXTEND_LAST_funlist: EXTEND_LAST_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
EXTEND_LAST_funlist_1  : EXTEND_LAST_fun{$$ = $1;}
     | EXTEND_LAST_funlist_1 ',' EXTEND_LAST_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
EXTEND_NEXT_fun:   naming EXTEND_NEXT_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming EXTEND_NEXT_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | EXTEND_NEXT_fun_1   {$$ = $1;} 
      | EXTEND_NEXT_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
EXTEND_NEXT_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"currenttuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"lasttuple");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
EXTEND_NEXT_funlist: EXTEND_NEXT_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
EXTEND_NEXT_funlist_1  : EXTEND_NEXT_fun{$$ = $1;}
     | EXTEND_NEXT_funlist_1 ',' EXTEND_NEXT_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
REPLACEATTR_fun:   naming REPLACEATTR_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming REPLACEATTR_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | REPLACEATTR_fun_1   {$$ = $1;} 
      | REPLACEATTR_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
REPLACEATTR_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
REPLACEATTR_funlist: REPLACEATTR_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
REPLACEATTR_funlist_1  : REPLACEATTR_fun{$$ = $1;}
     | REPLACEATTR_funlist_1 ',' REPLACEATTR_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
PFILTER_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"currenttuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"lasttuple");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
EXTENDX_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
ADDMODCOUNTER_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"value");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" int"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
USEHISTOGRAM_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"element");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
USEHISTOGRAM2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"element1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"element2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ELEMENT"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DMAPS_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"dmapelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DMAPS2_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DMAPS3_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) ))));
     cleanVariables(3); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DMAPS4_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem4");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG4"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) ))));
     cleanVariables(4); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DMAPS5_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem3");
     sprintf(params[3], "%s_%d",paramname,paramno);
     p = pair<int,string>(3, params[3]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem4");
     sprintf(params[4], "%s_%d",paramname,paramno);
     p = pair<int,string>(4, params[4]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem5");
     sprintf(params[5], "%s_%d",paramname,paramno);
     p = pair<int,string>(5, params[5]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[3]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG3"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[4]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG4"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[5]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG5"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) ))));
     cleanVariables(5); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DPRODUCTS_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"elem2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG1"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNFSARG2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
PARTITIONFS_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"arg1");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"arg2");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARGPARTITIONF"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARGPARTITIONF"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
DBSCAN_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
REGISTERFORSTREAM_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"elem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TTYPE3"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~Function~

*/
PREDCOUNTS_fun:   naming PREDCOUNTS_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming PREDCOUNTS_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | PREDCOUNTS_fun_1   {$$ = $1;} 
      | PREDCOUNTS_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
PREDCOUNTS_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
PREDCOUNTS_funlist: PREDCOUNTS_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
PREDCOUNTS_funlist_1  : PREDCOUNTS_fun{$$ = $1;}
     | PREDCOUNTS_funlist_1 ',' PREDCOUNTS_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
STPATTERNEXTEND_fun:   naming STPATTERNEXTEND_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming STPATTERNEXTEND_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | STPATTERNEXTEND_fun_1   {$$ = $1;} 
      | STPATTERNEXTEND_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
STPATTERNEXTEND_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
STPATTERNEXTEND_funlist: STPATTERNEXTEND_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
STPATTERNEXTEND_funlist_1  : STPATTERNEXTEND_fun{$$ = $1;}
     | STPATTERNEXTEND_funlist_1 ',' STPATTERNEXTEND_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
STPATTERNEXTEND2_fun:   naming STPATTERNEXTEND2_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming STPATTERNEXTEND2_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | STPATTERNEXTEND2_fun_1   {$$ = $1;} 
      | STPATTERNEXTEND2_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
STPATTERNEXTEND2_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
STPATTERNEXTEND2_funlist: STPATTERNEXTEND2_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
STPATTERNEXTEND2_funlist_1  : STPATTERNEXTEND2_fun{$$ = $1;}
     | STPATTERNEXTEND2_funlist_1 ',' STPATTERNEXTEND2_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
STPATTERNEXEXTEND_fun:   naming STPATTERNEXEXTEND_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming STPATTERNEXEXTEND_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | STPATTERNEXEXTEND_fun_1   {$$ = $1;} 
      | STPATTERNEXEXTEND_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
STPATTERNEXEXTEND_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
STPATTERNEXEXTEND_funlist: STPATTERNEXEXTEND_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
STPATTERNEXEXTEND_funlist_1  : STPATTERNEXEXTEND_fun{$$ = $1;}
     | STPATTERNEXEXTEND_funlist_1 ',' STPATTERNEXEXTEND_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
STPATTERNEXEXTEND2_fun:   naming STPATTERNEXEXTEND2_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming STPATTERNEXEXTEND2_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | STPATTERNEXEXTEND2_fun_1   {$$ = $1;} 
      | STPATTERNEXEXTEND2_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
STPATTERNEXEXTEND2_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
STPATTERNEXEXTEND2_funlist: STPATTERNEXEXTEND2_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
STPATTERNEXEXTEND2_funlist_1  : STPATTERNEXEXTEND2_fun{$$ = $1;}
     | STPATTERNEXEXTEND2_funlist_1 ',' STPATTERNEXEXTEND2_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
STPATTERNEXTENDSTREAM_fun:   naming STPATTERNEXTENDSTREAM_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming STPATTERNEXTENDSTREAM_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | STPATTERNEXTENDSTREAM_fun_1   {$$ = $1;} 
      | STPATTERNEXTENDSTREAM_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
STPATTERNEXTENDSTREAM_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
STPATTERNEXTENDSTREAM_funlist: STPATTERNEXTENDSTREAM_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
STPATTERNEXTENDSTREAM_funlist_1  : STPATTERNEXTENDSTREAM_fun{$$ = $1;}
     | STPATTERNEXTENDSTREAM_funlist_1 ',' STPATTERNEXTENDSTREAM_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
STPATTERNEXTENDSTREAM2_fun:   naming STPATTERNEXTENDSTREAM2_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming STPATTERNEXTENDSTREAM2_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | STPATTERNEXTENDSTREAM2_fun_1   {$$ = $1;} 
      | STPATTERNEXTENDSTREAM2_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
STPATTERNEXTENDSTREAM2_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
STPATTERNEXTENDSTREAM2_funlist: STPATTERNEXTENDSTREAM2_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
STPATTERNEXTENDSTREAM2_funlist_1  : STPATTERNEXTENDSTREAM2_fun{$$ = $1;}
     | STPATTERNEXTENDSTREAM2_funlist_1 ',' STPATTERNEXTENDSTREAM2_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
STPATTERNEXEXTENDSTREAM_fun:   naming STPATTERNEXEXTENDSTREAM_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming STPATTERNEXEXTENDSTREAM_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | STPATTERNEXEXTENDSTREAM_fun_1   {$$ = $1;} 
      | STPATTERNEXEXTENDSTREAM_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
STPATTERNEXEXTENDSTREAM_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
STPATTERNEXEXTENDSTREAM_funlist: STPATTERNEXEXTENDSTREAM_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
STPATTERNEXEXTENDSTREAM_funlist_1  : STPATTERNEXEXTENDSTREAM_fun{$$ = $1;}
     | STPATTERNEXEXTENDSTREAM_funlist_1 ',' STPATTERNEXEXTENDSTREAM_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~Function~

*/
STPATTERNEXEXTENDSTREAM2_fun:   naming STPATTERNEXEXTENDSTREAM2_fun_1
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
            NestedText::AtomC(")")  ))));} 
    |   naming STPATTERNEXEXTENDSTREAM2_fun_1  ZZDEFAULTSEP valueexpr
      {$$ = NestedText::Concat(NestedText::AtomC("("), 
            NestedText::Concat($1, 
            NestedText::Concat(NestedText::AtomC(" "),
            NestedText::Concat($2, 
              NestedText::Concat(NestedText::AtomC(" "),              NestedText::Concat(  $4 ,            NestedText::AtomC(")")  ))))));} 
      | STPATTERNEXEXTENDSTREAM2_fun_1   {$$ = $1;} 
      | STPATTERNEXEXTENDSTREAM2_fun_1  ZZDEFAULTSEP valueexpr 
      {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3));               } 
     ; 

/*
~function~

*/
STPATTERNEXEXTENDSTREAM2_fun_1 :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"streamelem");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~funlist~

*/
STPATTERNEXEXTENDSTREAM2_funlist: STPATTERNEXEXTENDSTREAM2_funlist_1 
     { $$=NestedText::Concat(NestedText::AtomC("( "),
               NestedText::Concat($1, 
               NestedText::AtomC(" ) ")));
      } 
     ; 

/*
~funlist~

*/
STPATTERNEXEXTENDSTREAM2_funlist_1  : STPATTERNEXEXTENDSTREAM2_fun{$$ = $1;}
     | STPATTERNEXEXTENDSTREAM2_funlist_1 ',' STPATTERNEXEXTENDSTREAM2_fun
      { $$ = NestedText::Concat($1,
            NestedText::Concat(NestedText::AtomC(" "), $3));
     }
      ; 

/*
~function~

*/
REDUCE_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"tuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
     cleanVariables(1); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
TSMOTIFBFFUN_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"lefttuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"righttuple");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" TUPLE2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;

/*
~function~

*/
TSDISTANCEFUN_fun :  { 
     pair<int,string> p; 
     paramno++; 
     strcpy(paramname,"lefttuple");
     sprintf(params[1], "%s_%d",paramname,paramno);
     p = pair<int,string>(1, params[1]);
     paramstack.push(p);
     paramno++; 
     strcpy(paramname,"righttuple");
     sprintf(params[2], "%s_%d",paramname,paramno);
     p = pair<int,string>(2, params[2]);
     paramstack.push(p);
     }
   valueexpr
     { 
     pair<int,string> p; 
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     p = paramstack.top(); 
     strcpy(params[p.first],p.second.c_str());
     paramstack.pop();
     $$ = NestedText::Concat( NestedText::AtomC("(fun "),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[1]),
     NestedText::Concat( NestedText::AtomC(" TUPLE"),
     NestedText::Concat(NestedText::AtomC(")"),
      NestedText::Concat( NestedText::AtomC("("),
      NestedText::Concat( NestedText::AtomC(params[2]),
     NestedText::Concat( NestedText::AtomC(" TUPLE2"),
     NestedText::Concat(NestedText::AtomC(")"),
         NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
     cleanVariables(2); 
     restoreVariables(); 
     }
     | function { $$ = $1; } 
     ;