diff --git a/src/c/apply.d b/src/c/apply.d
index 63ea793c0..520e83d64 100644
--- a/src/c/apply.d
+++ b/src/c/apply.d
@@ -343,331 +343,6 @@ APPLY(cl_narg n, cl_objectfn fn, cl_object *x)
   } 
 }
 
-cl_object
-APPLY_closure(cl_narg n, cl_objectfn fn, cl_object cl, cl_object *x)
-{
-  switch (n) {
-  case 0:  return (*fn)(n, cl);
-  case 1:  return (*fn)(n, cl, x[0]);
-  case 2:  return (*fn)(n, cl, x[0],x[1]);
-  case 3:  return (*fn)(n, cl, x[0],x[1],x[2]);
-  case 4:  return (*fn)(n, cl, x[0],x[1],x[2],x[3]);
-  case 5:  return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4]);
-  case 6:  return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5]);
-  case 7:  return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6]);
-  case 8:  return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7]);
-  case 9:  return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		     x[8]);
-  case 10: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9]);
-  case 11: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10]);
-  case 12: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11]);
-  case 13: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12]);
-  case 14: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13]);
-  case 15: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14]);
-  case 16: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15]);
-  case 17: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16]);
-  case 18: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17]);
-  case 19: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18]);
-  case 20: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19]);
-  case 21: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20]);
-  case 22: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21]);
-  case 23: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22]);
-  case 24: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23]);
-  case 25: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24]);
-  case 26: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25]);
-  case 27: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26]);
-  case 28: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27]);
-  case 29: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28]);
-  case 30: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29]);
-  case 31: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30]);
-  case 32: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31]);
-  case 33: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32]);
-  case 34: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33]);
-  case 35: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34]);
-  case 36: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35]);
-  case 37: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36]);
-  case 38: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37]);
-  case 39: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38]);
-  case 40: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39]);
-  case 41: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40]);
-  case 42: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41]);
-  case 43: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42]);
-  case 44: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43]);
-  case 45: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44]);
-  case 46: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45]);
-  case 47: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46]);
-  case 48: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47]);
-  case 49: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48]);
-  case 50: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48],x[49]);
-  case 51: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-		      x[50]);
-  case 52: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-		      x[50],x[51]);
-  case 53: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-		      x[50],x[51],x[52]);
-  case 54: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-	 	      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-		      x[50],x[51],x[52],x[53]);
-  case 55: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-		      x[50],x[51],x[52],x[53],x[54]);
-  case 56: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-		      x[50],x[51],x[52],x[53],x[54],x[55]);
-  case 57: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-		      x[50],x[51],x[52],x[53],x[54],x[55],x[56]);
-  case 58: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-		      x[50],x[51],x[52],x[53],x[54],x[55],x[56],
-		      x[57]);
-  case 59: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-		      x[50],x[51],x[52],x[53],x[54],x[55],x[56],
-		      x[57],x[58]);
-  case 60: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-		      x[50],x[51],x[52],x[53],x[54],x[55],x[56],
-		      x[57],x[58],x[59]);
-  case 61: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-		      x[50],x[51],x[52],x[53],x[54],x[55],x[56],
-		      x[57],x[58],x[59],x[60]);
-  case 62: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-		      x[50],x[51],x[52],x[53],x[54],x[55],x[56],
-		      x[57],x[58],x[59],x[60],x[61]);
-  case 63: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-		      x[50],x[51],x[52],x[53],x[54],x[55],x[56],
-		      x[57],x[58],x[59],x[60],x[61],x[62]);
-  default: return (*fn)(n, cl, x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-		      x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-		      x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-		      x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-		      x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-		      x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-		      x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-		      x[50],x[51],x[52],x[53],x[54],x[55],x[56],
-		      x[57],x[58],x[59],x[60],x[61],x[62],x[63]);
-  /* Arguments above 64 have been pushed on the stack */
-  }
-}
-
 cl_object
 APPLY_fixed(cl_narg n, cl_object (*fn)(), cl_object *x)
 {
diff --git a/src/c/arch/ffi_x86.d b/src/c/arch/ffi_x86.d
index a4fe8eb6e..88558a1d2 100644
--- a/src/c/arch/ffi_x86.d
+++ b/src/c/arch/ffi_x86.d
@@ -137,7 +137,7 @@ ecl_dynamic_callback_execute(cl_object cbk_info, char *arg_buffer)
 		}
 	}
 
-	result = ecl_apply_from_stack_frame(frame, fun);
+	result = ecl_apply_from_stack_frame(env, frame, fun);
 	ecl_stack_frame_close(frame);
 
 	tag = ecl_foreign_type_code(rtype);
diff --git a/src/c/assignment.d b/src/c/assignment.d
index 6638724ee..ddd18aed1 100644
--- a/src/c/assignment.d
+++ b/src/c/assignment.d
@@ -109,7 +109,6 @@ void
 ecl_clear_compiler_properties(cl_object sym)
 {
 	if (ecl_get_option(ECL_OPT_BOOTED)) {
-		si_unlink_symbol(sym);
 		funcall(2, @'si::clear-compiler-properties', sym);
 	}
 }
diff --git a/src/c/cfun.d b/src/c/cfun.d
index a6f7e2df8..f9bbc9df4 100644
--- a/src/c/cfun.d
+++ b/src/c/cfun.d
@@ -26,14 +26,14 @@ cl_make_cfun(void *c_function, cl_object name, cl_object cblock, int narg)
 	cl_object cf;
 
 	cf = ecl_alloc_object(t_cfunfixed);
-	cf->cfun.entry = dispatch_table[narg];
-	cf->cfun.orig = c_function;
-	cf->cfun.name = name;
-	cf->cfun.block = cblock;
-	cf->cfun.narg = narg;
+	cf->cfunfixed.entry = dispatch_table[narg];
+	cf->cfunfixed.orig = c_function;
+	cf->cfunfixed.name = name;
+	cf->cfunfixed.block = cblock;
+	cf->cfunfixed.narg = narg;
 	if (narg < 0 || narg > C_ARGUMENTS_LIMIT)
 	    FEprogram_error("cl_make_cfun: function requires too many arguments.",0);
-	return(cf);
+	return cf;
 }
 
 cl_object
diff --git a/src/c/cfun_dispatch.d b/src/c/cfun_dispatch.d
index 00baf0d33..9be60663a 100644
--- a/src/c/cfun_dispatch.d
+++ b/src/c/cfun_dispatch.d
@@ -3,452 +3,523 @@
     cfun_dispatch.c -- Trampolines for functions
 */
 
-static cl_object dispatch0 (cl_nargs nargs, cl_object x0) {
+static cl_object dispatch0 (cl_narg narg) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 0) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0);
+  return fun->cfunfixed.orig();
 }
 
-static cl_object dispatch1 (cl_nargs nargs, cl_object x0, cl_object x1) {
+static cl_object dispatch1 (cl_narg narg, cl_object x0) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 1) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1);
+  return fun->cfunfixed.orig(x0);
 }
 
-static cl_object dispatch2 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2) {
+static cl_object dispatch2 (cl_narg narg, cl_object x0, cl_object x1) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 2) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2);
+  return fun->cfunfixed.orig(x0, x1);
 }
 
-static cl_object dispatch3 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3) {
+static cl_object dispatch3 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 3) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3);
+  return fun->cfunfixed.orig(x0, x1, x2);
 }
 
-static cl_object dispatch4 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4) {
+static cl_object dispatch4 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 4) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4);
+  return fun->cfunfixed.orig(x0, x1, x2, x3);
 }
 
-static cl_object dispatch5 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5) {
+static cl_object dispatch5 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 5) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4);
 }
 
-static cl_object dispatch6 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6) {
+static cl_object dispatch6 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 6) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5);
 }
 
-static cl_object dispatch7 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7) {
+static cl_object dispatch7 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 7) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6);
 }
 
-static cl_object dispatch8 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8) {
+static cl_object dispatch8 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 8) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7);
 }
 
-static cl_object dispatch9 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9) {
+static cl_object dispatch9 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 9) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8);
 }
 
-static cl_object dispatch10 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10) {
+static cl_object dispatch10 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 10) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
 }
 
-static cl_object dispatch11 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11) {
+static cl_object dispatch11 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 11) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10);
 }
 
-static cl_object dispatch12 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12) {
+static cl_object dispatch12 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 12) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11);
 }
 
-static cl_object dispatch13 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13) {
+static cl_object dispatch13 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 13) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12);
 }
 
-static cl_object dispatch14 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14) {
+static cl_object dispatch14 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 14) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13);
 }
 
-static cl_object dispatch15 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15) {
+static cl_object dispatch15 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 15) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14);
 }
 
-static cl_object dispatch16 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16) {
+static cl_object dispatch16 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 16) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15);
 }
 
-static cl_object dispatch17 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17) {
+static cl_object dispatch17 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 17) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16);
 }
 
-static cl_object dispatch18 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18) {
+static cl_object dispatch18 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 18) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17);
 }
 
-static cl_object dispatch19 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19) {
+static cl_object dispatch19 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 19) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18);
 }
 
-static cl_object dispatch20 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20) {
+static cl_object dispatch20 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 20) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19);
 }
 
-static cl_object dispatch21 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21) {
+static cl_object dispatch21 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 21) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20);
 }
 
-static cl_object dispatch22 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22) {
+static cl_object dispatch22 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 22) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21);
 }
 
-static cl_object dispatch23 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23) {
+static cl_object dispatch23 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 23) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22);
 }
 
-static cl_object dispatch24 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24) {
+static cl_object dispatch24 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 24) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23);
 }
 
-static cl_object dispatch25 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25) {
+static cl_object dispatch25 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 25) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24);
 }
 
-static cl_object dispatch26 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26) {
+static cl_object dispatch26 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 26) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25);
 }
 
-static cl_object dispatch27 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27) {
+static cl_object dispatch27 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 27) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26);
 }
 
-static cl_object dispatch28 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28) {
+static cl_object dispatch28 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 28) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27);
 }
 
-static cl_object dispatch29 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29) {
+static cl_object dispatch29 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 29) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28);
 }
 
-static cl_object dispatch30 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30) {
+static cl_object dispatch30 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 30) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29);
 }
 
-static cl_object dispatch31 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31) {
+static cl_object dispatch31 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 31) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30);
 }
 
-static cl_object dispatch32 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32) {
+static cl_object dispatch32 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 32) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31);
 }
 
-static cl_object dispatch33 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33) {
+static cl_object dispatch33 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 33) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32);
 }
 
-static cl_object dispatch34 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34) {
+static cl_object dispatch34 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 34) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33);
 }
 
-static cl_object dispatch35 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35) {
+static cl_object dispatch35 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 35) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34);
 }
 
-static cl_object dispatch36 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36) {
+static cl_object dispatch36 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 36) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35);
 }
 
-static cl_object dispatch37 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37) {
+static cl_object dispatch37 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 37) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36);
 }
 
-static cl_object dispatch38 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38) {
+static cl_object dispatch38 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 38) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37);
 }
 
-static cl_object dispatch39 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39) {
+static cl_object dispatch39 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 39) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38);
 }
 
-static cl_object dispatch40 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40) {
+static cl_object dispatch40 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 40) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39);
 }
 
-static cl_object dispatch41 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41) {
+static cl_object dispatch41 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 41) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40);
 }
 
-static cl_object dispatch42 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42) {
+static cl_object dispatch42 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 42) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41);
 }
 
-static cl_object dispatch43 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43) {
+static cl_object dispatch43 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 43) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42);
 }
 
-static cl_object dispatch44 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44) {
+static cl_object dispatch44 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 44) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43);
 }
 
-static cl_object dispatch45 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45) {
+static cl_object dispatch45 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 45) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44);
 }
 
-static cl_object dispatch46 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46) {
+static cl_object dispatch46 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 46) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45);
 }
 
-static cl_object dispatch47 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47) {
+static cl_object dispatch47 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 47) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46);
 }
 
-static cl_object dispatch48 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48) {
+static cl_object dispatch48 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 48) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47);
 }
 
-static cl_object dispatch49 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49) {
+static cl_object dispatch49 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 49) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48);
 }
 
-static cl_object dispatch50 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50) {
+static cl_object dispatch50 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 50) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49);
 }
 
-static cl_object dispatch51 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51) {
+static cl_object dispatch51 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 51) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50);
 }
 
-static cl_object dispatch52 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52) {
+static cl_object dispatch52 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 52) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51);
 }
 
-static cl_object dispatch53 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53) {
+static cl_object dispatch53 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 53) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52);
 }
 
-static cl_object dispatch54 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54) {
+static cl_object dispatch54 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 54) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53);
 }
 
-static cl_object dispatch55 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55) {
+static cl_object dispatch55 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 55) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54);
 }
 
-static cl_object dispatch56 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56) {
+static cl_object dispatch56 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 56) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55);
 }
 
-static cl_object dispatch57 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57) {
+static cl_object dispatch57 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 57) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56);
 }
 
-static cl_object dispatch58 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58) {
+static cl_object dispatch58 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 58) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57);
 }
 
-static cl_object dispatch59 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58, cl_object x59) {
+static cl_object dispatch59 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 59) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58);
 }
 
-static cl_object dispatch60 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58, cl_object x59, cl_object x60) {
+static cl_object dispatch60 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58, cl_object x59) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 60) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59);
 }
 
-static cl_object dispatch61 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58, cl_object x59, cl_object x60, cl_object x61) {
+static cl_object dispatch61 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58, cl_object x59, cl_object x60) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 61) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60);
 }
 
-static cl_object dispatch62 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58, cl_object x59, cl_object x60, cl_object x61, cl_object x62) {
+static cl_object dispatch62 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58, cl_object x59, cl_object x60, cl_object x61) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 62) FEwrong_num_arguments(fun);
-  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61);
 }
 
-static cl_object dispatch63 (cl_nargs nargs, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58, cl_object x59, cl_object x60, cl_object x61, cl_object x62, cl_object x63) {
+static cl_object dispatch63 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58, cl_object x59, cl_object x60, cl_object x61, cl_object x62) {
   const cl_env_ptr the_env = ecl_process_env();
   cl_object fun = the_env->function;
   if (narg != 63) FEwrong_num_arguments(fun);
+  return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62);
+}
+
+static cl_object dispatch64 (cl_narg narg, cl_object x0, cl_object x1, cl_object x2, cl_object x3, cl_object x4, cl_object x5, cl_object x6, cl_object x7, cl_object x8, cl_object x9, cl_object x10, cl_object x11, cl_object x12, cl_object x13, cl_object x14, cl_object x15, cl_object x16, cl_object x17, cl_object x18, cl_object x19, cl_object x20, cl_object x21, cl_object x22, cl_object x23, cl_object x24, cl_object x25, cl_object x26, cl_object x27, cl_object x28, cl_object x29, cl_object x30, cl_object x31, cl_object x32, cl_object x33, cl_object x34, cl_object x35, cl_object x36, cl_object x37, cl_object x38, cl_object x39, cl_object x40, cl_object x41, cl_object x42, cl_object x43, cl_object x44, cl_object x45, cl_object x46, cl_object x47, cl_object x48, cl_object x49, cl_object x50, cl_object x51, cl_object x52, cl_object x53, cl_object x54, cl_object x55, cl_object x56, cl_object x57, cl_object x58, cl_object x59, cl_object x60, cl_object x61, cl_object x62, cl_object x63) {
+  const cl_env_ptr the_env = ecl_process_env();
+  cl_object fun = the_env->function;
+  if (narg != 64) FEwrong_num_arguments(fun);
   return fun->cfunfixed.orig(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63);
 }
 
-static dispatch_table[64] = {dispatch0, dispatch1, dispatch2, dispatch3, dispatch4, dispatch5, dispatch6, dispatch7, dispatch8, dispatch9, dispatch10, dispatch11, dispatch12, dispatch13, dispatch14, dispatch15, dispatch16, dispatch17, dispatch18, dispatch19, dispatch20, dispatch21, dispatch22, dispatch23, dispatch24, dispatch25, dispatch26, dispatch27, dispatch28, dispatch29, dispatch30, dispatch31, dispatch32, dispatch33, dispatch34, dispatch35, dispatch36, dispatch37, dispatch38, dispatch39, dispatch40, dispatch41, dispatch42, dispatch43, dispatch44, dispatch45, dispatch46, dispatch47, dispatch48, dispatch49, dispatch50, dispatch51, dispatch52, dispatch53, dispatch54, dispatch55, dispatch56, dispatch57, dispatch58, dispatch59, dispatch60, dispatch61, dispatch62, dispatch63};
+static cl_objectfn dispatch_table[64] = {
+(cl_objectfn)dispatch0, 
+(cl_objectfn)dispatch1, 
+(cl_objectfn)dispatch2, 
+(cl_objectfn)dispatch3, 
+(cl_objectfn)dispatch4, 
+(cl_objectfn)dispatch5, 
+(cl_objectfn)dispatch6, 
+(cl_objectfn)dispatch7, 
+(cl_objectfn)dispatch8, 
+(cl_objectfn)dispatch9, 
+(cl_objectfn)dispatch10, 
+(cl_objectfn)dispatch11, 
+(cl_objectfn)dispatch12, 
+(cl_objectfn)dispatch13, 
+(cl_objectfn)dispatch14, 
+(cl_objectfn)dispatch15, 
+(cl_objectfn)dispatch16, 
+(cl_objectfn)dispatch17, 
+(cl_objectfn)dispatch18, 
+(cl_objectfn)dispatch19, 
+(cl_objectfn)dispatch20, 
+(cl_objectfn)dispatch21, 
+(cl_objectfn)dispatch22, 
+(cl_objectfn)dispatch23, 
+(cl_objectfn)dispatch24, 
+(cl_objectfn)dispatch25, 
+(cl_objectfn)dispatch26, 
+(cl_objectfn)dispatch27, 
+(cl_objectfn)dispatch28, 
+(cl_objectfn)dispatch29, 
+(cl_objectfn)dispatch30, 
+(cl_objectfn)dispatch31, 
+(cl_objectfn)dispatch32, 
+(cl_objectfn)dispatch33, 
+(cl_objectfn)dispatch34, 
+(cl_objectfn)dispatch35, 
+(cl_objectfn)dispatch36, 
+(cl_objectfn)dispatch37, 
+(cl_objectfn)dispatch38, 
+(cl_objectfn)dispatch39, 
+(cl_objectfn)dispatch40, 
+(cl_objectfn)dispatch41, 
+(cl_objectfn)dispatch42, 
+(cl_objectfn)dispatch43, 
+(cl_objectfn)dispatch44, 
+(cl_objectfn)dispatch45, 
+(cl_objectfn)dispatch46, 
+(cl_objectfn)dispatch47, 
+(cl_objectfn)dispatch48, 
+(cl_objectfn)dispatch49, 
+(cl_objectfn)dispatch50, 
+(cl_objectfn)dispatch51, 
+(cl_objectfn)dispatch52, 
+(cl_objectfn)dispatch53, 
+(cl_objectfn)dispatch54, 
+(cl_objectfn)dispatch55, 
+(cl_objectfn)dispatch56, 
+(cl_objectfn)dispatch57, 
+(cl_objectfn)dispatch58, 
+(cl_objectfn)dispatch59, 
+(cl_objectfn)dispatch60, 
+(cl_objectfn)dispatch61, 
+(cl_objectfn)dispatch62, 
+(cl_objectfn)dispatch63};
diff --git a/src/c/eval.d b/src/c/eval.d
index 82f8e9bf8..e8af19966 100644
--- a/src/c/eval.d
+++ b/src/c/eval.d
@@ -74,7 +74,7 @@ ecl_apply_from_stack_frame(cl_env_ptr env, cl_object frame, cl_object x)
 		env->function = fun;
 		if (narg != (cl_index)fun->cfun.narg)
 			FEwrong_num_arguments(fun);
-		return APPLY_fixed(narg, fun->cfun.orig, sp);
+		return APPLY_fixed(narg, fun->cfunfixed.orig, sp);
 	case t_cfun:
 		env->function = fun;
 		return APPLY(narg, fun->cfun.entry, sp);
@@ -112,29 +112,53 @@ ecl_apply_from_stack_frame(cl_env_ptr env, cl_object frame, cl_object x)
 static cl_object
 _ecl_clos_dispatch(cl_narg narg, ...)
 {
+        int i;
+        cl_object output;
 	cl_env_ptr env = ecl_process_env();
 	struct ecl_stack_frame frame_aux;
 	const cl_object frame = ecl_stack_frame_open(env, (cl_object)&frame_aux, narg);
-	return _ecl_standard_dispatch(env, frame, env->function);
+        cl_va_list args; cl_va_start(args, narg, narg, 0);
+        for (i = 0; i < narg; i++) {
+                ecl_stack_frame_elt_set(frame, i, cl_va_arg(args));
+        }
+	output = _ecl_standard_dispatch(env, frame, env->function);
+        ecl_stack_frame_close(frame);
+        return output;
 }
 
 static cl_object
 _ecl_bytecodes_dispatch(cl_narg narg, ...)
 {
+        int i;
+        cl_object output;
 	cl_env_ptr env = ecl_process_env();
 	struct ecl_stack_frame frame_aux;
 	const cl_object frame = ecl_stack_frame_open(env, (cl_object)&frame_aux, narg);
-	return _ecl_interpret(frame, Cnil, env->function, 0);
+        cl_va_list args; cl_va_start(args, narg, narg, 0);
+        for (i = 0; i < narg; i++) {
+                ecl_stack_frame_elt_set(frame, i, cl_va_arg(args));
+        }
+	output = ecl_interpret(frame, Cnil, env->function, 0);
+        ecl_stack_frame_close(frame);
+        return output;
 }
 
 static cl_object
 _ecl_bclosure_dispatch(cl_narg narg, ...)
 {
+        int i;
+        cl_object output;
 	cl_env_ptr env = ecl_process_env();
 	cl_object fun = env->function;
 	struct ecl_stack_frame frame_aux;
 	const cl_object frame = ecl_stack_frame_open(env, (cl_object)&frame_aux, narg);
-	return _ecl_interpret(frame, fun->bclosure.lex, fun, 0);
+        cl_va_list args; cl_va_start(args, narg, narg, 0);
+        for (i = 0; i < narg; i++) {
+                ecl_stack_frame_elt_set(frame, i, cl_va_arg(args));
+        }
+	output = ecl_interpret(frame, fun->bclosure.lex, fun->bclosure.code, 0);
+        ecl_stack_frame_close(frame);
+        return output;
 }
 
 cl_objectfn
@@ -174,10 +198,10 @@ ecl_function_dispatch(cl_env_ptr env, cl_object x)
 		goto AGAIN;
 	case t_bytecodes:
 		env->function = fun;
-		return _ecl_interpret_dispatch;
+		return _ecl_bytecodes_dispatch;
 	case t_bclosure:
 		env->function = fun;
-		return _ecl_closure_dispatch;
+		return _ecl_bclosure_dispatch;
 	default:
 	ERROR:
 		FEinvalid_function(x);
@@ -187,18 +211,18 @@ ecl_function_dispatch(cl_env_ptr env, cl_object x)
 @(defun funcall (function &rest funargs)
 	struct ecl_stack_frame frame_aux;
 @
-	return ecl_apply_from_stack_frame(build_funcall_frame((cl_object)&frame_aux, funargs), function);
+	return ecl_apply_from_stack_frame(the_env, build_funcall_frame((cl_object)&frame_aux, funargs), function);
 @)
 
 @(defun apply (fun lastarg &rest args)
 @
 	if (narg == 2 && type_of(lastarg) == t_frame) {
-		return ecl_apply_from_stack_frame(lastarg, fun);
+		return ecl_apply_from_stack_frame(the_env, lastarg, fun);
 	} else {
 		cl_object out;
 		cl_index i;
 		struct ecl_stack_frame frame_aux;
-		const cl_object frame = ecl_stack_frame_open(ecl_process_env(),
+		const cl_object frame = ecl_stack_frame_open(the_env,
 							     (cl_object)&frame_aux,
 							     narg -= 2);
 		for (i = 0; i < narg; i++) {
@@ -219,7 +243,7 @@ ecl_function_dispatch(cl_env_ptr env, cl_object x)
 			ecl_stack_frame_push(frame, CAR(lastarg));
 			i++;
 		} end_loop_for_in;
-		out = ecl_apply_from_stack_frame(frame, fun);
+		out = ecl_apply_from_stack_frame(the_env, frame, fun);
 		ecl_stack_frame_close(frame);
 		return out;
 	}
diff --git a/src/c/gbc.d b/src/c/gbc.d
index 3f6271ff4..d8c64efda 100644
--- a/src/c/gbc.d
+++ b/src/c/gbc.d
@@ -648,9 +648,6 @@ sweep_phase(void)
 			switch (x->d.t) {
 #ifdef ENABLE_DLOPEN
 			case t_codeblock:
-				if (x->cblock.links) {
-					cl_mapc(2, @'si::unlink-symbol', x->cblock.links);
-				}
 				ecl_library_close(x);
 				break;
 #endif
diff --git a/src/c/hash.d b/src/c/hash.d
index c273373c8..5b55de9f4 100644
--- a/src/c/hash.d
+++ b/src/c/hash.d
@@ -608,9 +608,10 @@ cl_hash_table_count(cl_object ht)
 }
 
 static cl_object
-si_hash_table_iterate(cl_narg narg, cl_object env)
+si_hash_table_iterate(cl_narg narg)
 {
 	const cl_env_ptr the_env = ecl_process_env();
+        cl_object env = the_env->function;
 	cl_object index = CAR(env);
 	cl_object ht = CADR(env);
 	cl_fixnum i;
diff --git a/src/c/interpreter.d b/src/c/interpreter.d
index 91f5aa12e..5694ae60f 100644
--- a/src/c/interpreter.d
+++ b/src/c/interpreter.d
@@ -483,7 +483,7 @@ close_around(cl_object fun, cl_object lex) {
 	frame.stack = the_env->stack; \
 	frame.top = the_env->stack_top; \
 	frame.bottom = frame.top - __n; \
-	reg0 = ecl_apply_from_stack_frame((cl_object)&frame, fun); \
+	reg0 = ecl_apply_from_stack_frame(the_env, (cl_object)&frame, fun); \
 	the_env->stack_top -= __n; }
 
 /* -------------------- THE INTERPRETER -------------------- */
@@ -641,7 +641,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes, cl_index offs
 		cl_object s;
 		cl_objectfn_fixed f;
 		GET_DATA(s, vector, data);
-		f = (cl_objectfn_fixed)SYM_FUN(s)->cfun.entry;
+		f = SYM_FUN(s)->cfunfixed.orig;
 		SETUP_ENV(the_env);
 		reg0 = f(reg0);
 		THREAD_NEXT;
@@ -651,7 +651,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes, cl_index offs
 		cl_object s;
 		cl_objectfn_fixed f;
 		GET_DATA(s, vector, data);
-		f = (cl_objectfn_fixed)SYM_FUN(s)->cfun.entry;
+		f = SYM_FUN(s)->cfunfixed.orig;
 		SETUP_ENV(the_env);
 		reg0 = f(STACK_POP(the_env), reg0);
 		THREAD_NEXT;
@@ -711,16 +711,16 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes, cl_index offs
 		}
 		switch (type_of(reg0)) {
 		case t_cfunfixed:
-			if (narg != (cl_index)reg0->cfun.narg)
+			if (narg != (cl_index)reg0->cfunfixed.narg)
 				FEwrong_num_arguments(reg0);
-			reg0 = APPLY_fixed(narg, reg0->cfun.orig, frame_aux.bottom);
+			reg0 = APPLY_fixed(narg, reg0->cfunfixed.orig, frame_aux.bottom);
 			break;
 		case t_cfun:
 			reg0 = APPLY(narg, reg0->cfun.entry, frame_aux.bottom);
 			break;
 		case t_cclosure:
 			the_env->function = reg0->cclosure.env;
-			reg0 = APPLY_closure(narg, reg0->cclosure.entry, frame_aux.bottom);
+			reg0 = APPLY(narg, reg0->cclosure.entry, frame_aux.bottom);
 			break;
 #ifdef CLOS
 		case t_instance:
diff --git a/src/c/list.d b/src/c/list.d
index 10daeaf5c..35d2f04d3 100644
--- a/src/c/list.d
+++ b/src/c/list.d
@@ -29,6 +29,7 @@ struct cl_test {
 	cl_object frame_test;
 	struct ecl_stack_frame frame_test_aux;
 	cl_object frame_args[3];
+        cl_env_ptr env;
 };
 
 static cl_object subst(struct cl_test *t, cl_object new_obj, cl_object tree);
@@ -45,7 +46,7 @@ test_compare(struct cl_test *t, cl_object x)
 	ecl_stack_frame_elt_set(t->frame_test, 0, t->item_compared);
 	x = (t->key_c_function)(t, x);
 	ecl_stack_frame_elt_set(t->frame_test, 1, x);
-	return ecl_apply_from_stack_frame(t->frame_test, t->test_function) != Cnil;
+	return ecl_apply_from_stack_frame(t->env, t->frame_test, t->test_function) != Cnil;
 }
 
 static bool
@@ -54,7 +55,7 @@ test_compare_not(struct cl_test *t, cl_object x)
 	ecl_stack_frame_elt_set(t->frame_test, 0, t->item_compared);
 	x = (t->key_c_function)(t, x);
 	ecl_stack_frame_elt_set(t->frame_test, 1, x);
-	return ecl_apply_from_stack_frame(t->frame_test, t->test_function) == Cnil;
+	return ecl_apply_from_stack_frame(t->env, t->frame_test, t->test_function) == Cnil;
 }
 
 static bool
@@ -85,7 +86,7 @@ static cl_object
 key_function(struct cl_test *t, cl_object x)
 {
 	ecl_stack_frame_elt_set(t->frame_key, 0, x);
-	return ecl_apply_from_stack_frame(t->frame_key, t->key_function);
+	return ecl_apply_from_stack_frame(t->env, t->frame_key, t->key_function);
 }
 
 static cl_object
@@ -141,6 +142,7 @@ setup_test(struct cl_test *t, cl_object item, cl_object test,
 		t->frame_key_aux.top = t->frame_args + 3;
 		t->frame_key_aux.stack = 0;
 	}
+        t->env = ecl_process_env();
 }
 
 static void close_test(struct cl_test *t)
diff --git a/src/c/load.d b/src/c/load.d
index 460a6440f..f83f6857b 100644
--- a/src/c/load.d
+++ b/src/c/load.d
@@ -319,9 +319,6 @@ ecl_library_close(cl_object block) {
 		filename = "<anonymous>";
 	else
 		filename = (char*)block->cblock.name->base_string.self;
-	if (!Null(block->cblock.links)) {
-		cl_mapc(2, @'si::unlink-symbol', block->cblock.links);
-	}
         if (block->cblock.handle != NULL) {
 		if (verbose) {
 			fprintf(stderr, ";;; Freeing library %s\n", filename);
diff --git a/src/c/mapfun.d b/src/c/mapfun.d
index 748b5a2ad..81b7546aa 100644
--- a/src/c/mapfun.d
+++ b/src/c/mapfun.d
@@ -49,7 +49,7 @@
 			ecl_stack_frame_elt_set(cars_frame, i, CAR(cdr));
 			ecl_stack_frame_elt_set(cdrs_frame, i, CDR(cdr));
 		}
-		*val = ecl_list1(ecl_apply_from_stack_frame(cars_frame, fun));
+		*val = ecl_list1(ecl_apply_from_stack_frame(the_env, cars_frame, fun));
 		val = &ECL_CONS_CDR(*val);
 	}
 } @)
@@ -71,7 +71,7 @@
 			ecl_stack_frame_elt_set(cars_frame, i, cdr);
 			ecl_stack_frame_elt_set(cdrs_frame, i, CDR(cdr));
 		}
-		*val = ecl_list1(ecl_apply_from_stack_frame(cars_frame, fun));
+		*val = ecl_list1(ecl_apply_from_stack_frame(the_env, cars_frame, fun));
 		val = &ECL_CONS_CDR(*val);
 	}
 } @)
@@ -93,7 +93,7 @@
 			ecl_stack_frame_elt_set(cars_frame, i, CAR(cdr));
 			ecl_stack_frame_elt_set(cdrs_frame, i, CDR(cdr));
 		}
-		ecl_apply_from_stack_frame(cars_frame, fun);
+		ecl_apply_from_stack_frame(the_env, cars_frame, fun);
 	}
 } @)
 
@@ -114,7 +114,7 @@
 			ecl_stack_frame_elt_set(cars_frame, i, cdr);
 			ecl_stack_frame_elt_set(cdrs_frame, i, CDR(cdr));
 		}
-		ecl_apply_from_stack_frame(cars_frame, fun);
+		ecl_apply_from_stack_frame(the_env, cars_frame, fun);
 	}
 } @)
 
@@ -135,7 +135,7 @@
 			ecl_stack_frame_elt_set(cars_frame, i, CAR(cdr));
 			ecl_stack_frame_elt_set(cdrs_frame, i, CDR(cdr));
 		}
-		*val = ecl_apply_from_stack_frame(cars_frame, fun);
+		*val = ecl_apply_from_stack_frame(the_env, cars_frame, fun);
 		while (CONSP(*val))
 			val = &ECL_CONS_CDR(*val);
 	}
@@ -158,7 +158,7 @@
 			ecl_stack_frame_elt_set(cars_frame, i, cdr);
 			ecl_stack_frame_elt_set(cdrs_frame, i, CDR(cdr));
 		}
-		*val = ecl_apply_from_stack_frame(cars_frame, fun);
+		*val = ecl_apply_from_stack_frame(the_env, cars_frame, fun);
 		while (CONSP(*val))
 			val = &ECL_CONS_CDR(*val);
 	}
diff --git a/src/c/symbols_list.h b/src/c/symbols_list.h
index 81b234c8a..0aba06d54 100644
--- a/src/c/symbols_list.h
+++ b/src/c/symbols_list.h
@@ -1194,7 +1194,6 @@ cl_symbols[] = {
 {SYS_ "TERMINAL-INTERRUPT", SI_ORDINARY, NULL, -1, OBJNULL},
 {SYS_ "TOP-LEVEL", SI_ORDINARY, NULL, -1, OBJNULL},
 {SYS_ "UNIVERSAL-ERROR-HANDLER", SI_ORDINARY, NULL, -1, OBJNULL},
-{SYS_ "UNLINK-SYMBOL", SI_ORDINARY, si_unlink_symbol, 1, OBJNULL},
 {SYS_ "VALID-FUNCTION-NAME-P", SI_ORDINARY, si_valid_function_name_p, 1, OBJNULL},
 {SYS_ "WRITE-OBJECT", SI_SPECIAL, si_write_object, 2, OBJNULL},
 {SYS_ "WRITE-UGLY-OBJECT", SI_SPECIAL, si_write_ugly_object, 2, OBJNULL},
diff --git a/src/c/symbols_list2.h b/src/c/symbols_list2.h
index 5c0b4df50..392445efd 100644
--- a/src/c/symbols_list2.h
+++ b/src/c/symbols_list2.h
@@ -1194,7 +1194,6 @@ cl_symbols[] = {
 {SYS_ "TERMINAL-INTERRUPT",NULL},
 {SYS_ "TOP-LEVEL",NULL},
 {SYS_ "UNIVERSAL-ERROR-HANDLER",NULL},
-{SYS_ "UNLINK-SYMBOL","si_unlink_symbol"},
 {SYS_ "VALID-FUNCTION-NAME-P","si_valid_function_name_p"},
 {SYS_ "WRITE-OBJECT","si_write_object"},
 {SYS_ "WRITE-UGLY-OBJECT","si_write_ugly_object"},
diff --git a/src/cmp/cmpcall.lsp b/src/cmp/cmpcall.lsp
index 7bff03173..244418d0f 100644
--- a/src/cmp/cmpcall.lsp
+++ b/src/cmp/cmpcall.lsp
@@ -157,10 +157,7 @@
   (cond
     ;; Check whether it is a global function that we cannot call directly.
      ((and (or (null loc) (fun-global loc)) (not (inline-possible fname)))
-      (if (and *compile-to-linking-call*
-	       (<= (cmp-env-optimization 'debug) 1))
-	  (call-linking-loc fname narg args)
-	  (call-unknown-global-loc fname nil narg args)))
+      (call-unknown-global-loc fname nil narg args))
 
      ;; Open-codable function call.
      ((and (or (null loc) (fun-global loc))
@@ -193,30 +190,11 @@
      ((multiple-value-setq (found fd minarg maxarg) (si::mangle-name fname t))
       (call-exported-function-loc fname narg args fd minarg maxarg t))
 
-     ;; Linking calls can only be made to symbols
-     ((and *compile-to-linking-call* (<= (cmp-env-optimization 'debug) 1))
-      (call-linking-loc fname narg args))
-
      (t (call-unknown-global-loc fname loc narg args))))
 
 (defun call-loc (fname loc narg args)
   `(CALL-NORMAL ,loc ,(coerce-locs args)))
 
-(defun call-linking-loc (fname narg args &aux i)
-  (let ((fun (second (assoc fname *linking-calls*))))
-    (unless fun
-      (let* ((i (length *linking-calls*))
-             (c-id (lisp-to-c-name fname))
-	     (var-name (format nil "LK~d~A" i c-id))
-	     (c-name (format nil "LKF~d~A" i c-id)))
-	(cmpnote "Emitting linking call for ~a" fname)
-	(setf fun (make-fun :name fname :global t :lambda 'NIL
-			    :cfun (format nil "(*~A)" var-name)
-			    :minarg 0 :maxarg call-arguments-limit))
-	(setf *linking-calls* (cons (list fname fun (add-symbol fname) c-name var-name)
-				    *linking-calls*))))
-    (call-loc fname fun narg args)))
-
 (defun call-exported-function-loc (fname narg args fun-c-name minarg maxarg in-core)
   (unless in-core
     ;; We only write declarations for functions which are not in lisp_external.h
@@ -248,30 +226,15 @@
 ;;;   NARG is a location containing the number of ARGS-PUSHED
 ;;;
 (defun call-unknown-global-loc (fname loc narg args)
-  (unless loc
-    (setq loc
-	  (if (and (symbolp fname)
-		   (not (eql (symbol-package fname) (find-package "CL"))))
-	      (progn
-		(cmpnote "Emitting FUNCALL for ~S" fname)
-		(add-symbol fname))
-	      (progn
-		(cmpnote "Emitting FDEFINITION for ~S" fname)
-		(setq loc (list 'FDEFINITION fname))))))
-  (do ((i 0 (1+ i))
-       (l args (cdr l)))
-      ((endp l)
-       (progn
-	 (cond ((> i *max-stack*)
-		(setf *max-stack* i))
-	       ((zerop *max-stack*)
-		(setf *max-stack* 1)))
-	 (wt-nl +ecl-local-stack-frame-variable+ ".top = "
-		+ecl-local-stack-variable+ "+" i ";")
-	 `(CALL "ecl_apply_from_stack_frame" ((LOCAL-FRAME NIL) ,loc) ,fname)))
-    (wt-nl +ecl-local-stack-variable+ "[" i "]=")
-    (wt-coerce-loc :object (second (first l)))
-    (wt ";")))
+  `(CALL-INDIRECT ,(cond (loc loc)
+                         ((and (symbolp fname)
+                               (not (eql (symbol-package fname) (find-package "CL"))))
+                          (cmpnote "Emitting FUNCALL for ~S" fname)
+                          (add-symbol fname))
+                         (t
+                          (cmpnote "Emitting FDEFINITION for ~S" fname)
+                          (list 'FDEFINITION fname)))
+                  ,(or narg (length args)) ,(coerce-locs args)))
 
 ;;; Functions that use MAYBE-SAVE-VALUE should rebind *temp*.
 (defun maybe-save-value (value &optional (other-forms nil other-forms-flag))
@@ -303,17 +266,24 @@
 
 (defun wt-call (fun args &optional fname env)
   (if env
-    (progn
-     (wt "(cl_env_copy->function=" env ",")
-     (wt-call fun args)
-     (wt ")"))
-    (progn
-     (wt fun "(")
-     (let ((comma ""))
-       (dolist (arg args)
-	 (wt comma arg)
-	 (setf comma ",")))
-     (wt ")")))
+      (progn
+        (wt "(cl_env_copy->function=" env ",")
+        (wt-call fun args)
+        (wt ")"))
+      (progn
+        (wt fun "(")
+        (let ((comma ""))
+          (dolist (arg args)
+            (wt comma arg)
+            (setf comma ",")))
+        (wt ")")))
+  (when fname (wt-comment fname)))
+
+(defun wt-call-indirect (fun-loc narg args &optional fname)
+  (wt "ecl_function_dispatch(cl_env_copy," fun-loc ")(" narg)
+  (dolist (arg args)
+    (wt "," arg))
+  (wt ")")
   (when fname (wt-comment fname)))
 
 (defun wt-call-normal (fun args)
@@ -352,3 +322,4 @@
 
 (put-sysprop 'CALL 'WT-LOC #'wt-call)
 (put-sysprop 'CALL-NORMAL 'WT-LOC #'wt-call-normal)
+(put-sysprop 'CALL-INDIRECT 'WT-LOC #'wt-call-indirect)
diff --git a/src/cmp/cmpcbk.lsp b/src/cmp/cmpcbk.lsp
index 63e789df4..7be0c8979 100644
--- a/src/cmp/cmpcbk.lsp
+++ b/src/cmp/cmpcbk.lsp
@@ -109,7 +109,7 @@
                      n "," ct "));")
 	      (wt-nl "ecl_stack_frame_push(frame,ecl_make_foreign_data(&var"
                      n "," ct "," (ffi:size-of-foreign-type type) "));")))
-    (wt-nl "aux = ecl_apply_from_stack_frame(frame,"
+    (wt-nl "aux = ecl_apply_from_stack_frame(cl_env_copy,frame,"
            "ecl_fdefinition(" c-name-constant "));")
     (wt-nl "ecl_stack_frame_close(frame);")
     (when return-p
diff --git a/src/cmp/cmpdefs.lsp b/src/cmp/cmpdefs.lsp
index 872bc2c39..70e09c510 100644
--- a/src/cmp/cmpdefs.lsp
+++ b/src/cmp/cmpdefs.lsp
@@ -283,7 +283,7 @@ progress. The default value is T.")
 (defvar *suppress-compiler-notes* nil) ; Deprecated
 (defvar *suppress-compiler-warnings* nil) ; Deprecated
 
-(defvar *compiler-break-enable* nil)
+(defvar *compiler-break-enable* t)
 
 (defvar *compiler-in-use* nil)
 (defvar *compiler-input*)
@@ -339,8 +339,6 @@ progress. The default value is T.")
 (defvar *next-cmacro* 0)	; holds the last cmacro number used.
 (defvar *next-cfun* 0)		; holds the last cfun used.
 
-(defvar *max-stack* 0)		; maximum space used in lisp stack
-
 ;;;
 ;;; *tail-recursion-info* holds NIL, if tail recursion is impossible.
 ;;; If possible, *tail-recursion-info* holds
diff --git a/src/cmp/cmpenv.lsp b/src/cmp/cmpenv.lsp
index 501ed62e5..11a219d16 100644
--- a/src/cmp/cmpenv.lsp
+++ b/src/cmp/cmpenv.lsp
@@ -22,7 +22,6 @@
   '((*compiler-in-use* t)
     (*compiler-phase* 't1)
     (*callbacks* nil)
-    (*max-stack* 0)
     (*max-temp* 0)
     (*temp* 0)
     (*next-cmacro* 0)
diff --git a/src/cmp/cmploc.lsp b/src/cmp/cmploc.lsp
index 1bb307952..60d2536f3 100644
--- a/src/cmp/cmploc.lsp
+++ b/src/cmp/cmploc.lsp
@@ -29,6 +29,7 @@
 ;;;	( FRAME ndx )			variable in local frame stack
 ;;;	( CALL c-fun-name args fname )	locs are locations containing the arguments
 ;;;	( CALL-NORMAL fun locs)		similar as CALL, but number of arguments is fixed
+;;;	( CALL-INDIRECT fun narg args)	similar as CALL, but unknown function
 ;;;	( C-INLINE output-type fun/string locs side-effects output-var )
 ;;;	( COERCE-LOC representation-type location)
 ;;;	( CAR lcl )
@@ -68,7 +69,8 @@
 
 (defun set-loc (loc &aux fd
 		    (is-call (and (consp loc)
-				  (member (car loc) '(CALL CALL-NORMAL)  :test #'eq))))
+				  (member (car loc) '(CALL CALL-NORMAL CALL-INDIRECT)
+                                          :test #'eq))))
   (when (eql *destination* loc)
     (return-from set-loc))
   (case *destination*
@@ -186,14 +188,8 @@
 (defun values-loc (n)
   (list 'VALUE n))
 
-(defun wt-local-frame (n)
-  (if n
-      (wt +ecl-local-stack-variable+ "[" n "]")
-      (wt "((cl_object)&" +ecl-local-stack-frame-variable+ ")")))
-
 ;;; -----------------------------------------------------------------
 
-(put-sysprop 'LOCAL-FRAME 'WT-LOC #'wt-local-frame)
 (put-sysprop 'TEMP 'WT-LOC #'wt-temp)
 (put-sysprop 'LCL 'WT-LOC #'wt-lcl-loc)
 (put-sysprop 'VV 'WT-LOC #'wt-vv)
diff --git a/src/cmp/cmpstack.lsp b/src/cmp/cmpstack.lsp
index f78016c06..260e96604 100644
--- a/src/cmp/cmpstack.lsp
+++ b/src/cmp/cmpstack.lsp
@@ -77,7 +77,7 @@
 
 (defun c1apply-from-stack-frame (args)
   (c1expr `(c-inline ,args (t t) (values &rest t)
-		     "cl_env_copy->values[0]=ecl_apply_from_stack_frame(#0,#1);"
+		     "cl_env_copy->values[0]=ecl_apply_from_stack_frame(cl_env_copy,#0,#1);"
 		     :one-liner nil :side-effects t)))
 
 (put-sysprop 'with-stack 'C1 #'c1with-stack)
diff --git a/src/cmp/cmptop.lsp b/src/cmp/cmptop.lsp
index cd1e33a82..088521cfc 100644
--- a/src/cmp/cmptop.lsp
+++ b/src/cmp/cmptop.lsp
@@ -112,7 +112,6 @@
     (wt-nl-h "#include <string.h>"))
   ;;; Initialization function.
   (let* ((*lcl* 0) (*lex* 0) (*max-lex* 0) (*max-env* 0) (*max-temp* 0)
-	 (*max-stack* 0)
 	 (*reservation-cmacro* (next-cmacro))
 	 (c-output-file *compiler-output1*)
 	 (*compiler-output1* (make-string-output-stream))
@@ -374,10 +373,6 @@
     (wt-h " volatile cl_object lex" *level* "[" *max-lex* "];"))
   (wt-nl-h "#define CLSR" *reservation-cmacro*)
   (wt-nl-h "#define STCK" *reservation-cmacro*)
-  (unless (zerop *max-stack*)
-    (wt-h " cl_object " +ecl-local-stack-variable+ "[" *max-stack* "]; "
-	  "struct ecl_stack_frame " +ecl-local-stack-frame-variable+
-	  " = { t_frame, 0, 0, 0, " +ecl-local-stack-variable+ ", 0, 0 };"))
   (when (plusp *max-env*)
     (unless (eq closure-type 'CLOSURE)
       (wt-h " cl_object " *volatile* "env0;"))
diff --git a/src/cmp/sysfun.lsp b/src/cmp/sysfun.lsp
index 0c6807398..71a2687ef 100644
--- a/src/cmp/sysfun.lsp
+++ b/src/cmp/sysfun.lsp
@@ -351,7 +351,6 @@
 (proclaim-function evalhook (t t t *) t)
 (proclaim-function applyhook (t t t t *) t)
 (proclaim-function constantp (t) t :predicate t)
-(proclaim-function si:unlink-symbol (*) t)
 (proclaim-function si::link-enable (*) t)
 
 ;; file file.d
diff --git a/src/h/external.h b/src/h/external.h
index 346eab47f..6f49d30db 100644
--- a/src/h/external.h
+++ b/src/h/external.h
@@ -13,6 +13,9 @@ struct cl_env_struct {
 	/* Flag for disabling interrupts while we call C library functions. */
 	volatile int disable_interrupts;
 
+        /* Environment for calling closures, CLOS generic functions, etc */
+        cl_object function;
+
 	/* The four stacks in ECL. */
 
 	/*
@@ -276,7 +279,6 @@ extern ECL_API cl_index cl_num_symbols_in_core;
 
 extern ECL_API cl_object APPLY_fixed(cl_narg n, cl_object (*f)(), cl_object *x);
 extern ECL_API cl_object APPLY(cl_narg n, cl_objectfn, cl_object *x);
-extern ECL_API cl_object APPLY_closure(cl_narg n, cl_objectfn, cl_object cl, cl_object *x);
 
 
 /* array.c */
diff --git a/src/h/object.h b/src/h/object.h
index bcf072067..fde585bea 100644
--- a/src/h/object.h
+++ b/src/h/object.h
@@ -830,6 +830,7 @@ union cl_lispunion {
 	struct ecl_bytecodes	bytecodes; 	/*  bytecompiled function / code */
 	struct ecl_bclosure	bclosure; 	/*  bytecompiled closure */
 	struct ecl_cfun		cfun;		/*  compiled function  */
+	struct ecl_cfunfixed	cfunfixed;	/*  compiled function  */
 	struct ecl_cclosure	cclosure; 	/*  compiled closure  */
 
 	struct ecl_dummy	d;		/*  dummy  */