Merge pull request #5 from WinampDesktop/community

Merge to main

14 files changed, 9082 insertions, 0 deletions

diff --git a/Src/Plugins/Visualization/vis_milk2/ns-eel2/asm-nseel-ppc-gcc.c b/Src/Plugins/Visualization/vis_milk2/ns-eel2/asm-nseel-ppc-gcc.c
new file mode 100644
index 00000000..19a09ba8
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_milk2/ns-eel2/asm-nseel-ppc-gcc.c
@@ -0,0 +1,1041 @@
+#if EEL_F_SIZE == 8
+
+void nseel_asm_1pdd(void)
+{
+
+  __asm__( 
+    "addis r5, 0, 0xdead\n" 
+    "ori r5, r5, 0xbeef\n"  
+    "lfd f1, 0(r3)\n" 
+    "mtctr r5\n" 
+    "subi r1, r1, 64\n" 
+    "bctrl\n" 
+    "addi r1, r1, 64\n" 
+    "stfdu f1, 8(r16)\n" 
+    "mr r3, r16\n" 
+   :: );
+}
+void nseel_asm_1pdd_end(void){}
+
+void nseel_asm_2pdd(void)
+{
+
+  __asm__( 
+    "addis r7, 0, 0xdead\n" 
+    "ori r7, r7, 0xbeef\n"  
+    "lfd f2, 0(r3)\n" 
+    "lfd f1, 0(r14)\n" 
+    "mtctr r7\n" 
+    "subi r1, r1, 64\n" 
+    "bctrl\n" 
+    "addi r1, r1, 64\n" 
+    "stfdu f1, 8(r16)\n" 
+    "mr r3, r16\n" 
+   :: );
+};
+void nseel_asm_2pdd_end(void){}
+
+void nseel_asm_2pdds(void)
+{
+  __asm__( 
+    "addis r5, 0, 0xdead\n" 
+    "ori r5, r5, 0xbeef\n"  
+    "lfd f2, 0(r3)\n" 
+    "lfd f1, 0(r14)\n" 
+    "mtctr r5\n" 
+    "subi r1, r1, 64\n" 
+    "bctrl\n" 
+    "addi r1, r1, 64\n" 
+    "stfd f1, 0(r14)\n" 
+    "mr r3, r14\n" 
+   :: );
+}
+void nseel_asm_2pdds_end(void){}
+
+#else // 32 bit floating point calls
+
+#error mac only can do 64 bit floats for now
+
+#endif
+
+
+void nseel_asm_2pp(void)
+{
+// r3=firstparm, r4=second parm, returns in f1
+  __asm__( 
+    "addis r5, 0, 0xdead\n" 
+    "ori r5, r5, 0xbeef\n"  
+    "mtctr r5\n" 
+    "mr r4, r3\n" 
+    "mr r3, r14\n" 
+    "subi r1, r1, 64\n" 
+    "bctrl\n" 
+    "addi r1, r1, 64\n" 
+    "stfdu f1, 8(r16)\n" 
+    "mr r3, r16\n" 
+   :: );
+};
+void nseel_asm_2pp_end(void){}
+
+void nseel_asm_1pp(void)
+{
+  __asm__( 
+    "addis r5, 0, 0xdead\n" 
+    "ori r5, r5, 0xbeef\n"  
+    "mtctr r5\n" 
+    "subi r1, r1, 64\n" 
+    "bctrl\n" 
+    "addi r1, r1, 64\n" 
+    "stfdu f1, 8(r16)\n" 
+    "mr r3, r16\n" 
+   :: );
+};
+void nseel_asm_1pp_end(void){}
+
+
+//---------------------------------------------------------------------------------------------------------------
+
+
+
+// do nothing, eh
+void nseel_asm_exec2(void)
+{
+}
+void nseel_asm_exec2_end(void) { }
+
+
+
+void nseel_asm_invsqrt(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "frsqrte f1, f1\n" // less accurate than our x86 equivilent, but invsqrt() is inherently inaccurate anyway
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+  );
+}
+void nseel_asm_invsqrt_end(void) {}
+
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_sqr(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "fmul f1, f1, f1\n"
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+  );
+}
+void nseel_asm_sqr_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_abs(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "fabs f1, f1\n"
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+  );
+}
+void nseel_asm_abs_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_assign(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "stfd f1, 0(r14)\n"
+  );
+}
+void nseel_asm_assign_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_add(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "lfd f2, 0(r14)\n"
+   "fadd f1, f1, f2\n"
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+  );
+}
+void nseel_asm_add_end(void) {}
+
+void nseel_asm_add_op(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "lfd f2, 0(r14)\n"
+   "fadd f1, f1, f2\n"
+   "stfd f1, 0(r14)\n"
+   "mr r3, r14\n"
+  );
+}
+void nseel_asm_add_op_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_sub(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "lfd f2, 0(r14)\n"
+   "fsub f1, f2, f1\n"
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+  );
+}
+void nseel_asm_sub_end(void) {}
+
+void nseel_asm_sub_op(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "lfd f2, 0(r14)\n"
+   "fsub f1, f2, f1\n"
+   "stfd f1, 0(r14)\n"
+   "mr r3, r14\n"
+  );
+}
+void nseel_asm_sub_op_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_mul(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "lfd f2, 0(r14)\n"
+   "fmul f1, f2, f1\n"
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+  );
+}
+void nseel_asm_mul_end(void) {}
+
+void nseel_asm_mul_op(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "lfd f2, 0(r14)\n"
+   "fmul f1, f2, f1\n"
+   "stfd f1, 0(r14)\n"
+   "mr r3, r14\n"
+  );
+}
+void nseel_asm_mul_op_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_div(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "lfd f2, 0(r14)\n"
+   "fdiv f1, f2, f1\n"
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+  );
+}
+void nseel_asm_div_end(void) {}
+
+void nseel_asm_div_op(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "lfd f2, 0(r14)\n"
+   "fdiv f1, f2, f1\n"
+   "stfd f1, 0(r14)\n"
+   "mr r3, r14\n"
+  );
+}
+void nseel_asm_div_op_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_mod(void)
+{
+  __asm__(
+
+   "lfd f1, 0(r3)\n"
+   "lfd f2, 0(r14)\n"
+   "fabs f1, f1\n"
+   "fabs f2, f2\n"
+   "fctiwz f1, f1\n"
+   "fctiwz f2, f2\n"
+   "stfd f1, 8(r16)\n"
+   "stfd f2, 16(r16)\n"
+   "lwz r10, 12(r16)\n"
+   "lwz r11, 20(r16)\n" //r11 and r12 have the integers
+
+   "divw r12, r11, r10\n"
+   "mullw r12, r12, r10\n"
+   "subf r10, r12, r11\n"
+
+   "addis r11, 0, 0x4330\n"
+   "addis r12, 0, 0x8000\n"
+   "xoris r10, r10, 0x8000\n"
+   "stw r11, 8(r16)\n"   // 0x43300000
+   "stw r10, 12(r16)\n"  // our integer sign flipped
+   "stw r11, 16(r16)\n"  // 0x43300000
+   "stw r12, 20(r16)\n"  // 0x80000000
+   "lfd f1, 8(r16)\n"
+   "lfd f2, 16(r16)\n"
+   "fsub f1, f1, f2\n"
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+
+
+  );
+}
+void nseel_asm_mod_end(void) {}
+
+void nseel_asm_mod_op(void)
+{
+
+  __asm__(
+
+   "lfd f1, 0(r3)\n"
+   "lfd f2, 0(r14)\n"
+   "fabs f1, f1\n"
+   "fabs f2, f2\n"
+   "fctiwz f1, f1\n"
+   "fctiwz f2, f2\n"
+   "stfd f1, 8(r16)\n"
+   "stfd f2, 16(r16)\n"
+   "lwz r10, 12(r16)\n"
+   "lwz r11, 20(r16)\n" //r11 and r12 have the integers
+
+   "divw r12, r11, r10\n"
+   "mullw r12, r12, r10\n"
+   "subf r10, r12, r11\n"
+
+   "addis r11, 0, 0x4330\n"
+   "addis r12, 0, 0x8000\n"
+   "xoris r10, r10, 0x8000\n"
+   "stw r11, 8(r16)\n"   // 0x43300000
+   "stw r10, 12(r16)\n"  // our integer sign flipped
+   "stw r11, 16(r16)\n"  // 0x43300000
+   "stw r12, 20(r16)\n"  // 0x80000000
+   "lfd f1, 8(r16)\n"
+   "lfd f2, 16(r16)\n"
+   "fsub f1, f1, f2\n"
+   "stfd f1, 0(r14)\n"
+   "mr r3, r14\n"
+  );
+
+}
+void nseel_asm_mod_op_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_or(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "lfd f2, 0(r14)\n"
+   "fctiwz f1, f1\n"
+   "fctiwz f2, f2\n"
+   "stfd f1, 8(r16)\n"
+   "stfd f2, 16(r16)\n"
+   "lwz r10, 12(r16)\n"
+   "lwz r11, 20(r16)\n" //r11 and r12 have the integers
+   "or r10, r10, r11\n" // r10 has the result
+   "addis r11, 0, 0x4330\n"
+   "addis r12, 0, 0x8000\n"
+   "xoris r10, r10, 0x8000\n"
+   "stw r11, 8(r16)\n"   // 0x43300000
+   "stw r10, 12(r16)\n"  // our integer sign flipped
+   "stw r11, 16(r16)\n"  // 0x43300000
+   "stw r12, 20(r16)\n"  // 0x80000000
+   "lfd f1, 8(r16)\n"
+   "lfd f2, 16(r16)\n"
+   "fsub f1, f1, f2\n"
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+  );
+}
+void nseel_asm_or_end(void) {}
+
+void nseel_asm_or_op(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "lfd f2, 0(r14)\n"
+   "fctiwz f1, f1\n"
+   "fctiwz f2, f2\n"
+   "stfd f1, 8(r16)\n"
+   "stfd f2, 16(r16)\n"
+   "lwz r10, 12(r16)\n"
+   "lwz r11, 20(r16)\n" //r11 and r12 have the integers
+   "or r10, r10, r11\n" // r10 has the result
+   "addis r11, 0, 0x4330\n"
+   "addis r12, 0, 0x8000\n"
+   "xoris r10, r10, 0x8000\n"
+   "stw r11, 8(r16)\n"   // 0x43300000
+   "stw r10, 12(r16)\n"  // our integer sign flipped
+   "stw r11, 16(r16)\n"  // 0x43300000
+   "stw r12, 20(r16)\n"  // 0x80000000
+   "lfd f1, 8(r16)\n"
+   "lfd f2, 16(r16)\n"
+   "fsub f1, f1, f2\n"
+   "stfd f1, 0(r14)\n"
+   "mr r3, r14\n"
+  );
+}
+void nseel_asm_or_op_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_and(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "lfd f2, 0(r14)\n"
+   "fctiwz f1, f1\n"
+   "fctiwz f2, f2\n"
+   "stfd f1, 8(r16)\n"
+   "stfd f2, 16(r16)\n"
+   "lwz r10, 12(r16)\n"
+   "lwz r11, 20(r16)\n" //r11 and r12 have the integers
+   "and r10, r10, r11\n" // r10 has the result
+   "addis r11, 0, 0x4330\n"
+   "addis r12, 0, 0x8000\n"
+   "xoris r10, r10, 0x8000\n"
+   "stw r11, 8(r16)\n"   // 0x43300000
+   "stw r10, 12(r16)\n"  // our integer sign flipped
+   "stw r11, 16(r16)\n"  // 0x43300000
+   "stw r12, 20(r16)\n"  // 0x80000000
+   "lfd f1, 8(r16)\n"
+   "lfd f2, 16(r16)\n"
+   "fsub f1, f1, f2\n"
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+  );}
+void nseel_asm_and_end(void) {}
+
+void nseel_asm_and_op(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "lfd f2, 0(r14)\n"
+   "fctiwz f1, f1\n"
+   "fctiwz f2, f2\n"
+   "stfd f1, 8(r16)\n"
+   "stfd f2, 16(r16)\n"
+   "lwz r10, 12(r16)\n"
+   "lwz r11, 20(r16)\n" //r11 and r12 have the integers
+   "and r10, r10, r11\n" // r10 has the result
+   "addis r11, 0, 0x4330\n"
+   "addis r12, 0, 0x8000\n"
+   "xoris r10, r10, 0x8000\n"
+   "stw r11, 8(r16)\n"   // 0x43300000
+   "stw r10, 12(r16)\n"  // our integer sign flipped
+   "stw r11, 16(r16)\n"  // 0x43300000
+   "stw r12, 20(r16)\n"  // 0x80000000
+   "lfd f1, 8(r16)\n"
+   "lfd f2, 16(r16)\n"
+   "fsub f1, f1, f2\n"
+   "stfd f1, 0(r14)\n"
+   "mr r3, r14\n"
+  );
+}
+void nseel_asm_and_op_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_uplus(void) // this is the same as doing nothing, it seems
+{
+}
+void nseel_asm_uplus_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_uminus(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "fneg f1, f1\n"
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+  );
+}
+void nseel_asm_uminus_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_sign(void)
+{
+  __asm__(
+    "lfd f1, 0(r3)\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "lfd f2, 0(r5)\n"
+    "lis r9, 0xbff0\n"
+    "fcmpu cr7, f1, f2\n"
+    "blt- cr7, 0f\n"
+    "ble- cr7, 1f\n"
+    "  lis r9, 0x3ff0\n"
+    "0:\n"
+    "  li r10, 0\n"
+    "  stwu r9, 8(r16)\n"
+    "  stw  r10, 4(r16)\n"
+    "  b 2f\n"
+    "1:\n"
+    "  stfdu f1, 8(r16)\n"
+    "2:\n"
+    "  mr r3, r16\n"
+    :: 
+  );
+}
+void nseel_asm_sign_end(void) {}
+
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_bnot(void)
+{
+  __asm__(
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "lfd f2, 0(r5)\n"
+    "lfd f1, 0(r3)\n"
+    "fabs f1, f1\n"
+    "fcmpu cr7, f1, f2\n"
+    "blt cr7, 0f\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "lfd f1, 0(r5)\n"
+    "b 1f\n"
+    "0:\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "lfd f1, 0(r5)\n"
+    "1:\n"
+    "  stfdu f1, 8(r16)\n"
+    "  mr r3, r16\n"
+    :: 
+  );
+}
+void nseel_asm_bnot_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_if(void)
+{
+  __asm__(
+   "addis r5, 0, 0xdead\n"
+   "ori r5, r5, 0xbeef\n"
+   "lfd f2, 0(r5)\n"
+   "lfd f1, 0(r3)\n"
+   "addis r6, 0, 0xdead\n"
+   "ori r6, r6, 0xbeef\n"
+   "addis r7, 0, 0xdead\n"
+   "ori r7, r7, 0xbeef\n"
+   "fabs f1, f1\n"
+   "fcmpu cr7, f1, f2\n"
+   "blt cr7, 0f\n"
+   "  mtctr r6\n"
+   "b 1f\n"
+   "0:\n"
+   "  mtctr r7\n"
+   "1:\n"
+   "bctrl\n"
+  :: );
+}
+void nseel_asm_if_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_repeat(void)
+{
+  __asm__(
+   "addis r6, 0, 0xdead\n"
+   "ori r6, r6, 0xbeef\n"
+   "addis r7, 0, ha16(%0)\n"
+   "addi r7, r7, lo16(%0)\n"
+   "lfd f1, 0(r3)\n"
+   "fctiwz f1, f1\n"
+   "stfd f1, 8(r16)\n"
+   "lwz r5, 12(r16)\n" // r5 has count now
+   "cmpwi cr0, r5, 0\n"
+   "ble cr0, 1f\n"
+   "cmpw cr0, r7, r5\n"
+   "bge cr0, 0f\n"
+   "mr r5, r7\n" // set r5 to max if we have to
+"0:\n"
+   "stw r5, -4(r1)\n"
+   "stw r6, -8(r1)\n"
+   "stwu r16, -12(r1)\n"
+
+   "mtctr r6\n"
+   "bctrl\n"
+
+   "lwz r16, 0(r1)\n"
+   "lwz r6, 4(r1)\n"
+   "lwz r5, 8(r1)\n"
+   "addi r1, r1, 12\n"
+   "addi r5, r5, -1\n"
+
+   "cmpwi cr0, r5, 0\n"
+   "bgt cr0, 0b\n"
+   "1:\n"
+    ::"g" (NSEEL_LOOPFUNC_SUPPORT_MAXLEN)
+  );
+}
+void nseel_asm_repeat_end(void) {}
+
+void nseel_asm_repeatwhile(void)
+{
+  __asm__(
+   "addis r6, 0, 0xdead\n"
+   "ori r6, r6, 0xbeef\n"
+   "addis r5, 0, ha16(%0)\n"
+   "addi r5, r5, lo16(%0)\n"
+"0:\n"
+   "stw r5, -4(r1)\n"
+   "stw r6, -8(r1)\n"
+   "stwu r16, -12(r1)\n"
+
+   "mtctr r6\n"
+   "bctrl\n"
+
+   "lwz r16, 0(r1)\n"
+   "lwz r6, 4(r1)\n"
+   "lwz r5, 8(r1)\n"
+   "addi r1, r1, 12\n"
+   "addi r5, r5, -1\n"
+
+   "addis r7, 0, 0xdead\n"
+   "ori r7, r7, 0xbeef\n"
+   "lfd f2, 0(r7)\n"
+
+   "lfd f1, 0(r3)\n"
+   "fabs f1, f1\n"
+   "fcmpu cr7, f1, f2\n"
+   "blt cr7, 1f\n"
+
+   "cmpwi cr0, r5, 0\n"
+   "bgt cr0, 0b\n"
+   "1:\n"
+    ::"g" (NSEEL_LOOPFUNC_SUPPORT_MAXLEN)
+  );
+}
+void nseel_asm_repeatwhile_end(void) {}
+
+
+void nseel_asm_band(void)
+{
+  __asm__(
+
+   "addis r5, 0, 0xdead\n"
+   "ori r5, r5, 0xbeef\n"
+   "lfd f2, 0(r5)\n"
+   "lfd f1, 0(r3)\n"
+   "fabs f1, f1\n"
+   "fcmpu cr7, f1, f2\n"
+   "blt cr7, 0f\n"
+   "addis r6, 0, 0xdead\n"
+   "ori r6, r6, 0xbeef\n"
+   "  mtctr r6\n"
+   "  bctrl\n"
+   "  addis r5, 0, 0xdead\n"
+   "  ori r5, r5, 0xbeef\n"
+   "  lfd f2, 0(r5)\n"
+   "  lfd f1, 0(r3)\n"
+   "  fabs f1, f1\n"
+   "  fcmpu cr7, f1, f2\n"
+   "  bge cr7, 1f\n"
+   "0:\n"
+   "  fsub f1, f1, f1\n" // set f1 to 0!
+   "  b 2f\n"
+   "1:\n"
+   "  addis r5, 0, 0xdead\n" // set f1 to 1
+   "  ori r5, r5, 0xbeef\n"
+   "  lfd f1, 0(r5)\n"
+   "2:\n"
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+  :: );
+}
+void nseel_asm_band_end(void) {}
+
+void nseel_asm_bor(void)
+{
+  __asm__(
+   "addis r5, 0, 0xdead\n"
+   "ori r5, r5, 0xbeef\n"
+   "lfd f2, 0(r5)\n"
+   "lfd f1, 0(r3)\n"
+   "fabs f1, f1\n"
+   "fcmpu cr7, f1, f2\n"
+   "bge cr7, 0f\n"
+   "addis r6, 0, 0xdead\n"
+   "ori r6, r6, 0xbeef\n"
+   "  mtctr r6\n"
+   "  bctrl\n"
+   "  addis r5, 0, 0xdead\n"
+   "  ori r5, r5, 0xbeef\n"
+   "  lfd f2, 0(r5)\n"
+   "  lfd f1, 0(r3)\n"
+   "  fabs f1, f1\n"
+   "  fcmpu cr7, f1, f2\n"
+   "  blt cr7, 1f\n"
+   "0:\n"
+   "  addis r5, 0, 0xdead\n" // set f1 to 1
+   "  ori r5, r5, 0xbeef\n"
+   "  lfd f1, 0(r5)\n"
+   "  b 2f\n"
+   "1:\n"
+   "  fsub f1, f1, f1\n" // set f1 to 0!
+   "2:\n"
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+  :: );
+}
+void nseel_asm_bor_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_equal(void)
+{
+  __asm__(
+    "lfd f1, 0(r3)\n"
+    "lfd f2, 0(r14)\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "fsub f1, f1, f2\n"
+    "fabs f1, f1\n"
+    "lfd f2, 0(r5)\n"
+    "fcmpu cr7, f1, f2\n"
+    "blt cr7, 0f\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "b 1f\n"
+    "0:\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "1:\n"
+    "lfd f1, 0(r5)\n"
+    "  stfdu f1, 8(r16)\n"
+    "  mr r3, r16\n"
+    :: 
+  );
+}
+void nseel_asm_equal_end(void) {}
+//
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_notequal(void)
+{
+  __asm__(
+    "lfd f1, 0(r3)\n"
+    "lfd f2, 0(r14)\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "fsub f1, f1, f2\n"
+    "fabs f1, f1\n"
+    "lfd f2, 0(r5)\n"
+    "fcmpu cr7, f1, f2\n"
+    "blt cr7, 0f\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "b 1f\n"
+    "0:\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "1:\n"
+    "lfd f1, 0(r5)\n"
+    "  stfdu f1, 8(r16)\n"
+    "  mr r3, r16\n"
+    :: 
+  );
+}
+void nseel_asm_notequal_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_below(void)
+{
+  __asm__(
+    "lfd f1, 0(r3)\n"
+    "lfd f2, 0(r14)\n"
+    "fcmpu cr7, f2, f1\n"
+    "blt cr7, 0f\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "lfd f1, 0(r5)\n"
+    "b 1f\n"
+    "0:\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "lfd f1, 0(r5)\n"
+    "1:\n"
+    "  stfdu f1, 8(r16)\n"
+    "  mr r3, r16\n"
+    ::
+  );
+}
+void nseel_asm_below_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_beloweq(void)
+{
+  __asm__(
+    "lfd f1, 0(r3)\n"
+    "lfd f2, 0(r14)\n"
+    "fcmpu cr7, f2, f1\n"
+    "ble cr7, 0f\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "lfd f1, 0(r5)\n"
+    "b 1f\n"
+    "0:\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "lfd f1, 0(r5)\n"
+    "1:\n"
+    "  stfdu f1, 8(r16)\n"
+    "  mr r3, r16\n"
+    :: 
+  );
+}
+void nseel_asm_beloweq_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_above(void)
+{
+  __asm__(
+    "lfd f1, 0(r3)\n"
+    "lfd f2, 0(r14)\n"
+    "fcmpu cr7, f2, f1\n"
+    "bgt cr7, 0f\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "lfd f1, 0(r5)\n"
+    "b 1f\n"
+    "0:\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "lfd f1, 0(r5)\n"
+    "1:\n"
+    "  stfdu f1, 8(r16)\n"
+    "  mr r3, r16\n"
+    ::
+  );
+}
+void nseel_asm_above_end(void) {}
+
+void nseel_asm_aboveeq(void)
+{
+  __asm__(
+    "lfd f1, 0(r3)\n"
+    "lfd f2, 0(r14)\n"
+    "fcmpu cr7, f2, f1\n"
+    "bge cr7, 0f\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "lfd f1, 0(r5)\n"
+    "b 1f\n"
+    "0:\n"
+    "addis r5, 0, 0xdead\n"
+    "ori r5, r5, 0xbeef\n"
+    "lfd f1, 0(r5)\n"
+    "1:\n"
+    "  stfdu f1, 8(r16)\n"
+    "  mr r3, r16\n"
+    :: 
+  );
+}
+void nseel_asm_aboveeq_end(void) {}
+
+
+
+void nseel_asm_min(void)
+{
+  __asm__(
+    "lfd f1, 0(r3)\n"
+    "lfd f2, 0(r14)\n"
+    "fcmpu cr7, f2, f1\n"
+    "bgt cr7, 0f\n"
+    "fmr f1, f2\n"
+    "0:\n"
+    "  stfdu f1, 8(r16)\n"
+    "  mr r3, r16\n"
+  );
+}
+void nseel_asm_min_end(void) {}
+
+void nseel_asm_max(void)
+{
+  __asm__(
+    "lfd f1, 0(r3)\n"
+    "lfd f2, 0(r14)\n"
+    "fcmpu cr7, f2, f1\n"
+    "blt cr7, 0f\n"
+    "fmr f1, f2\n"
+    "0:\n"
+    "  stfdu f1, 8(r16)\n"
+    "  mr r3, r16\n"
+  );
+}
+
+void nseel_asm_max_end(void) {}
+
+
+
+
+
+
+
+
+
+void _asm_generic3parm(void)
+{
+  __asm__(
+   "mr r6, r3\n"
+   "addis r3, 0, 0xdead\n"
+   "ori r3, r3, 0xbeef\n"
+   "addis r7, 0, 0xdead\n"
+   "ori r7, r7, 0xbeef\n"
+   "mr r4, r15\n"
+   "mr r5, r14\n"
+   "mtctr r7\n"
+   "subi r1, r1, 64\n"
+   "bctrl\n"
+   "addi r1, r1, 64\n"
+  ::
+ ); 
+}
+void _asm_generic3parm_end(void) {}
+
+void _asm_generic3parm_retd(void)
+{
+  __asm__(
+   "mr r6, r3\n"
+   "addis r3, 0, 0xdead\n"
+   "ori r3, r3, 0xbeef\n"
+   "addis r7, 0, 0xdead\n"
+   "ori r7, r7, 0xbeef\n"
+   "mr r4, r15\n"
+   "mr r5, r14\n"
+   "mtctr r7\n"
+   "subi r1, r1, 64\n"
+   "bctrl\n"
+   "addi r1, r1, 64\n"
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+  ::
+ ); 
+}
+void _asm_generic3parm_retd_end(void) {}
+
+
+void _asm_generic2parm(void) // this prob neds to be fixed for ppc
+{
+  __asm__(
+   "mr r5, r3\n"
+   "addis r3, 0, 0xdead\n"
+   "ori r3, r3, 0xbeef\n"
+   "addis r7, 0, 0xdead\n"
+   "ori r7, r7, 0xbeef\n"
+   "mr r4, r14\n"
+   "mtctr r7\n"
+   "subi r1, r1, 64\n"
+   "bctrl\n"
+   "addi r1, r1, 64\n"
+  ::
+ ); 
+}
+void _asm_generic2parm_end(void) {}
+
+
+void _asm_generic2parm_retd(void)
+{
+  __asm__(
+   "mr r5, r3\n"
+   "addis r3, 0, 0xdead\n"
+   "ori r3, r3, 0xbeef\n"
+   "addis r7, 0, 0xdead\n"
+   "ori r7, r7, 0xbeef\n"
+   "mr r4, r14\n"
+   "mtctr r7\n"
+   "subi r1, r1, 64\n"
+   "bctrl\n"
+   "addi r1, r1, 64\n"
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+  ::
+ ); 
+}
+void _asm_generic2parm_retd_end(void) {}
+
+void _asm_generic1parm(void) // this prob neds to be fixed for ppc
+{
+  __asm__(
+   "mr r4, r3\n"
+   "addis r3, 0, 0xdead\n"
+   "ori r3, r3, 0xbeef\n"
+   "addis r7, 0, 0xdead\n"
+   "ori r7, r7, 0xbeef\n"
+   "mtctr r7\n"
+   "subi r1, r1, 64\n"
+   "bctrl\n"
+   "addi r1, r1, 64\n"
+  ::
+ ); 
+}
+void _asm_generic1parm_end(void) {}
+
+
+
+void _asm_generic1parm_retd(void)
+{
+  __asm__(
+   "mr r4, r3\n"
+   "addis r3, 0, 0xdead\n"
+   "ori r3, r3, 0xbeef\n"
+   "addis r7, 0, 0xdead\n"
+   "ori r7, r7, 0xbeef\n"
+   "mtctr r7\n"
+   "subi r1, r1, 64\n"
+   "bctrl\n"
+   "addi r1, r1, 64\n"
+   "stfdu f1, 8(r16)\n"
+   "mr r3, r16\n"
+  ::
+ ); 
+}
+void _asm_generic1parm_retd_end(void) {}
+
+
+
+
+void _asm_megabuf(void)
+{
+  __asm__(
+   "lfd f1, 0(r3)\n"
+   "addis r3, 0, 0xdead\n" // set up context pointer
+   "ori r3, r3, 0xbeef\n"
+   "addis r4, 0, 0xdead\n"
+   "ori r4, r4, 0xbeef\n"
+   "lfd f2, 0(r4)\n"
+   "fadd f1, f2, f1\n"
+   "addis r7, 0, 0xdead\n"
+   "ori r7, r7, 0xbeef\n"
+   "mtctr r7\n"
+   "fctiwz f1, f1\n"
+   "stfd f1, 8(r16)\n"
+   "lwz r4, 12(r16)\n"
+   "subi r1, r1, 64\n"
+   "bctrl\n"
+   "addi r1, r1, 64\n"
+   "cmpi cr0, r3, 0\n"
+   "bne cr0, 0f\n"
+   "sub r5, r5, r5\n"
+   "stwu r5, 8(r16)\n"
+   "stw r5, 4(r16)\n"
+   "mr r3, r16\n"
+   "0:\n"
+  ::
+ ); 
+}
+
+void _asm_megabuf_end(void) {}
diff --git a/Src/Plugins/Visualization/vis_milk2/ns-eel2/asm-nseel-x64-macho.o b/Src/Plugins/Visualization/vis_milk2/ns-eel2/asm-nseel-x64-macho.o
new file mode 100644
index 00000000..76e918ed
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_milk2/ns-eel2/asm-nseel-x64-macho.o
diff --git a/Src/Plugins/Visualization/vis_milk2/ns-eel2/asm-nseel-x86-gcc.c b/Src/Plugins/Visualization/vis_milk2/ns-eel2/asm-nseel-x86-gcc.c
new file mode 100644
index 00000000..e7cd7e94
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_milk2/ns-eel2/asm-nseel-x86-gcc.c
@@ -0,0 +1,1566 @@
+#if defined(__APPLE__)
+#define SAVE_STACK "pushl %ebp\nmovl %esp, %ebp\nandl $-16, %esp\n"
+#define RESTORE_STACK "leave\n"
+#else
+#define SAVE_STACK
+#define RESTORE_STACK
+#endif
+
+/* note: only EEL_F_SIZE=8 is now supported (no float EEL_F's) */
+
+void nseel_asm_1pdd(void)
+{
+  __asm__(
+	  SAVE_STACK 
+#ifdef TARGET_X64
+      "movq (%eax), %xmm0\n"
+	  "subl $128, %rsp\n"
+     "movl $0xffffffff, %edi\n" 
+#ifdef AMD64ABI
+     "movl %rsi, %r15\n"
+     "call *%edi\n" 
+     "movl %r15, %rsi\n"
+     "movq xmm0, (%r15)\n"
+#else
+     "call *%edi\n" 
+     "movq xmm0, (%esi)\n"
+#endif
+     "addl $128, %rsp\n"
+#else
+              "subl $8, %esp\n" /* keep stack aligned */ 
+					    "pushl 4(%eax)\n" /* push parameter */ 
+					    "pushl (%eax)\n"    /* push the rest of the parameter */ 
+              "movl $0xffffffff, %edi\n" 
+					    "call *%edi\n" 
+					    "fstpl (%esi)\n" /* store result */ 
+					    "addl $16, %esp\n" 
+#endif
+					    "movl %esi, %eax\n" /* set return value */ 
+					    "addl $8, %esi\n" /* advance worktab ptr */ 
+  	RESTORE_STACK 
+  );
+}
+void nseel_asm_1pdd_end(void){}
+
+void nseel_asm_2pdd(void)
+{
+  __asm__(
+	SAVE_STACK
+#ifdef TARGET_X64
+    "movq (%eax), xmm1\n"
+    "movq (%edi), xmm0\n"
+	"subl $128, %rsp\n"
+    "movl $0xffffffff, %edi\n"
+#ifdef AMD64ABI
+    "movl %rsi, %r15\n"
+    "call *%edi\n"
+    "movl %r15, %rsi\n"
+    "movq xmm0, (%r15)\n"
+#else
+    "call *%edi\n"
+    "movq xmm0, (%esi)\n"
+#endif
+    "addl $128, %rsp\n"
+#else
+					    "pushl 4(%eax)\n" /* push parameter */
+					    "pushl (%eax)\n"    /* push the rest of the parameter */
+					    "pushl 4(%edi)\n" /* push parameter */
+					    "pushl (%edi)\n"    /* push the rest of the parameter */
+              "movl $0xffffffff, %edi\n"
+					    "call *%edi\n"
+					    "fstpl (%esi)\n" /* store result */
+					    "addl $16, %esp\n"
+#endif
+					    "movl %esi, %eax\n" /* set return value */
+					    "addl $8, %esi\n" /* advance worktab ptr */
+	RESTORE_STACK
+  );
+}
+void nseel_asm_2pdd_end(void){}
+
+void nseel_asm_2pdds(void)
+{
+  __asm__(
+	SAVE_STACK
+#ifdef TARGET_X64
+    "movq (%eax), xmm1\n"
+    "movq (%edi), xmm0\n"
+	"subl $128, %rsp\n"
+    "movl $0xffffffff, %eax\n"
+#ifdef AMD64ABI
+    "movl %rsi, %r15\n"
+    "movl %rdi, %r14\n"
+    "call *%eax\n"
+    "movl %r15, %rsi\n"
+    "movq xmm0, (%r14)\n"
+    "movl %r14, %rax\n" /* set return value */
+#else
+    "call *%eax\n"
+    "movq xmm0, (%edi)\n"
+    "movl %edi, %eax\n" /* set return value */
+#endif
+    "subl $128, %rsp\n"
+#else
+					    "pushl 4(%eax)\n" /* push parameter */
+					    "pushl (%eax)\n"    /* push the rest of the parameter */
+					    "pushl 4(%edi)\n" /* push parameter */
+					    "pushl (%edi)\n"    /* push the rest of the parameter */
+              "movl $0xffffffff, %eax\n"
+					    "call *%eax\n"
+					    "fstpl (%edi)\n" /* store result */
+					    "addl $16, %esp\n"
+    "movl %edi, %eax\n" /* set return value */
+#endif
+RESTORE_STACK
+  );
+}
+void nseel_asm_2pdds_end(void){}
+
+void nseel_asm_2pp(void)
+{
+    __asm__(
+SAVE_STACK
+#ifdef TARGET_X64
+
+#ifdef AMD64ABI
+    "movl %rsi, %r15\n"
+    /* rdi is first parameter */
+    "movl %rax, %rsi\n"
+    "subl $128, %rsp\n"
+              "movl $0xffffffff, %eax\n" 
+					    "call *%eax\n" 
+    "movl %r15, %rsi\n"
+    "movq xmm0, (%r15)\n"
+#else
+              "movl %edi, %ecx\n"
+              "movl %eax, %edx\n"
+              "subl $128, %rsp\n"
+    "movl $0xffffffff, %edi\n"
+    "call *%edi\n"
+    "movq xmm0, (%esi)\n"
+#endif
+    "addl $128, %rsp\n"
+#else
+              "subl $8, %esp\n" /* keep stack aligned */
+              "pushl %eax\n" /* push parameter */
+					    "pushl %edi\n"    /* push second parameter */
+              "movl $0xffffffff, %edi\n"
+					    "call *%edi\n"
+					    "fstp" EEL_F_SUFFIX " (%esi)\n" /* store result */
+					    "addl $16, %esp\n"
+#endif
+					    "movl %esi, %eax\n" /* set return value */
+					    "addl $" EEL_F_SSTR ", %esi\n" /* advance worktab ptr */
+RESTORE_STACK
+  );
+}
+void nseel_asm_2pp_end(void) {}
+  
+
+void nseel_asm_1pp(void)
+{
+__asm__(
+SAVE_STACK
+#ifdef TARGET_X64
+#ifdef AMD64ABI
+    "movl %rsi, %r15\n"
+    "movl %eax, %edi\n"
+    "subl $128, %rsp\n"
+    "movl $0xffffffff, %rax\n"
+    "call *%rax\n"
+    "movl %r15, %rsi\n"
+    "movq xmm0, (%r15)\n"
+#else
+              "movl %eax, %ecx\n"
+              "subl $128, %rsp\n"
+    "movl $0xffffffff, %edi\n"
+    "call *%edi\n"
+    "movq xmm0, (%esi)\n"
+#endif
+    "addl $128, %rsp\n"
+#else
+              "subl $12, %esp\n" /* keep stack aligned */
+					    "pushl %eax\n" /* push parameter */
+              "movl $0xffffffff, %edi\n"
+              "call *%edi\n"
+					    "fstp" EEL_F_SUFFIX " (%esi)\n" /* store result */
+					    "addl $16, %esp\n"
+#endif
+					    "movl %esi, %eax\n" /* set return value */
+					    "addl $" EEL_F_SSTR ", %esi\n" /* advance worktab ptr */
+RESTORE_STACK
+  );
+}
+void nseel_asm_1pp_end(void){}
+
+
+
+//---------------------------------------------------------------------------------------------------------------
+
+
+// do nothing, eh
+void nseel_asm_exec2(void)
+{
+   __asm__(
+      ""
+    );
+}
+void nseel_asm_exec2_end(void) { }
+
+
+
+void nseel_asm_invsqrt(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "movl $0x5f3759df, %edx\n"
+    "fsts (%esi)\n"
+#ifdef TARGET_X64
+    "movl 0xffffffff, %rax\n"
+    "subl %ecx, %ecx\n"
+    "fmul" EEL_F_SUFFIX " (%rax)\n"
+#else
+    "fmul" EEL_F_SUFFIX " (0xffffffff)\n"
+#endif
+    "movl (%esi), %ecx\n"
+    "sarl $1, %ecx\n"
+    "subl %ecx, %edx\n"
+    "movl %edx, (%esi)\n"
+    "fmuls (%esi)\n"
+    "fmuls (%esi)\n"
+#ifdef TARGET_X64
+    "movl 0xffffffff, %rax\n"
+    "fadd" EEL_F_SUFFIX " (%rax)\n"
+#else
+    "fadd" EEL_F_SUFFIX " (0xffffffff)\n"
+#endif
+    "fmuls (%esi)\n"
+    "movl %esi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_invsqrt_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_sin(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fsin\n"
+    "movl %esi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_sin_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_cos(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fcos\n"
+    "movl %esi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_cos_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_tan(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fptan\n"
+    "movl %esi, %eax\n"
+    "fstp %st(0)\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_tan_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_sqr(void)
+{
+  __asm__(
+	"fld" EEL_F_SUFFIX " (%eax)\n"
+    "fmul %st(0), %st(0)\n"
+    "movl %esi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_sqr_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_sqrt(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fabs\n"
+    "fsqrt\n"
+    "movl %esi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_sqrt_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_log(void)
+{
+  __asm__(
+    "fldln2\n"
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "movl %esi, %eax\n"
+    "fyl2x\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_log_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_log10(void)
+{
+  __asm__(
+    "fldlg2\n"
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "movl %esi, %eax\n"
+    "fyl2x\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+    
+  );
+}
+void nseel_asm_log10_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_abs(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fabs\n"
+    "movl %esi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_abs_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_assign(void)
+{
+#ifdef TARGET_X64
+
+  __asm__(
+    "movll (%rax), %rdx\n"
+    "movll %rdx, %rcx\n"
+    "shrl $32, %rdx\n"
+    "andl $0x7FF00000, %edx\n"
+    "jz 1f\n"
+    "cmpl $0x7FF00000, %edx\n"
+    "je 1f\n"
+    "jmp 0f\n"
+    "1:\n"
+    "subl %rcx, %rcx\n"
+    "0:\n"
+    "movll %rcx, (%edi)\n"
+    );
+
+#else
+
+
+#if EEL_F_SIZE == 8
+  __asm__(
+    "movl 4(%eax), %edx\n"
+    "movl (%eax), %ecx\n"
+    "andl  $0x7ff00000, %edx\n"
+    "jz 1f\n"   // if exponent=zero, zero
+    "cmpl  $0x7ff00000, %edx\n"
+    "je 1f\n" // if exponent=all 1s, zero
+    "movl 4(%eax), %edx\n" // reread
+    "jmp 0f\n"
+    "1:\n"
+    "subl %ecx, %ecx\n"
+    "subl %edx, %edx\n"
+    "0:\n"
+    "movl %ecx, (%edi)\n"
+    "movl %edx, 4(%edi)\n"
+  );
+#else
+  __asm__(
+    "movl (%eax), %ecx\n"
+    "movl %ecx, (%edi)\n"
+  );
+#endif
+
+#endif
+
+}
+void nseel_asm_assign_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_add(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fadd" EEL_F_SUFFIX " (%edi)\n"
+    "movl %esi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_add_end(void) {}
+
+void nseel_asm_add_op(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fadd" EEL_F_SUFFIX " (%edi)\n"
+    "movl %edi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%edi)\n"
+  );
+}
+void nseel_asm_add_op_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_sub(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%edi)\n"
+    "fsub" EEL_F_SUFFIX " (%eax)\n"
+    "movl %esi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_sub_end(void) {}
+
+void nseel_asm_sub_op(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%edi)\n"
+    "fsub" EEL_F_SUFFIX " (%eax)\n"
+    "movl %edi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%edi)\n"
+  );
+}
+void nseel_asm_sub_op_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_mul(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%edi)\n"
+    "fmul" EEL_F_SUFFIX " (%eax)\n"
+    "movl %esi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_mul_end(void) {}
+
+void nseel_asm_mul_op(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fmul" EEL_F_SUFFIX " (%edi)\n"
+    "movl %edi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%edi)\n"
+  );
+}
+void nseel_asm_mul_op_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_div(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%edi)\n"
+    "fdiv" EEL_F_SUFFIX " (%eax)\n"
+    "movl %esi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_div_end(void) {}
+
+void nseel_asm_div_op(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%edi)\n"
+    "fdiv" EEL_F_SUFFIX " (%eax)\n"
+    "movl %edi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%edi)\n"
+  );
+}
+void nseel_asm_div_op_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_mod(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%edi)\n"
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fabs\n"
+    "fistpl (%esi)\n"
+    "fabs\n"
+    "fistpl 4(%esi)\n"
+    "xorl %edx, %edx\n"
+#ifdef TARGET_X64
+    "subl %eax, %eax\n"
+#endif
+    "cmpl $0, (%esi)\n"
+    "je 0f\n" // skip devide, set return to 0
+    "movl 4(%esi), %eax\n"
+    "divl (%esi)\n"
+    "0:\n"
+    "movl %edx, (%esi)\n"
+    "fildl (%esi)\n"
+    "movl %esi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_mod_end(void) {}
+
+void nseel_asm_mod_op(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%edi)\n"
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fabs\n"
+    "fistpl (%edi)\n"
+    "fabs\n"
+    "fistpl (%esi)\n"
+#ifdef TARGET_X64
+    "subl %eax, %eax\n"
+#endif
+    "xorl %edx, %edx\n"
+    "cmpl $0, (%edi)\n"
+    "je 0f\n" // skip devide, set return to 0
+    "movl (%esi), %eax\n"
+    "divl (%edi)\n"
+    "0:\n"
+    "movl %edx, (%edi)\n"
+    "fildl (%edi)\n"
+    "movl %edi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%edi)\n"
+    );
+}
+void nseel_asm_mod_op_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_or(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%edi)\n"
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "movl %esi, %eax\n"
+    "fistpll (%esi)\n"
+    "fistpll 8(%esi)\n"
+#ifdef TARGET_X64
+    "movll 8(%rsi), %rdi\n"
+    "orll %rdi, (%rsi)\n"
+#else
+    "movl 8(%esi), %edi\n"
+    "movl 12(%esi), %ecx\n"
+    "orl %edi, (%esi)\n"
+    "orl %ecx, 4(%esi)\n"
+#endif
+    "fildll (%esi)\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_or_end(void) {}
+
+void nseel_asm_or_op(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%edi)\n"
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fistpll (%edi)\n"
+    "fistpll (%esi)\n"
+#ifdef TARGET_X64
+    "movll (%rsi), %rax\n"
+    "orll %rax, (%rdi)\n"
+#else
+    "movl (%esi), %eax\n"
+    "movl 4(%esi), %ecx\n"
+    "orl %eax, (%edi)\n"
+    "orl %ecx, 4(%edi)\n"
+#endif
+    "fildll (%edi)\n"
+    "movl %edi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%edi)\n"
+  );
+}
+void nseel_asm_or_op_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_and(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%edi)\n"
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "movl %esi, %eax\n"
+    "fistpll (%esi)\n"
+    "fistpll 8(%esi)\n"
+#ifdef TARGET_X64
+    "movll 8(%rsi), %rdi\n"
+    "andll %rdi, (%rsi)\n"
+#else
+    "movl 8(%esi), %edi\n"
+    "movl 12(%esi), %ecx\n"
+    "andl %edi, (%esi)\n"
+    "andl %ecx, 4(%esi)\n"
+#endif
+    "fildll (%esi)\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_and_end(void) {}
+
+void nseel_asm_and_op(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%edi)\n"
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fistpll (%edi)\n"
+    "fistpll (%esi)\n"
+#ifdef TARGET_X64
+    "movll (%rsi), %rax\n"
+    "andll %rax, (%rdi)\n"
+#else
+    "movl (%esi), %eax\n"
+    "movl 4(%esi), %ecx\n"
+    "andl %eax, (%edi)\n"
+    "andl %ecx, 4(%edi)\n"
+#endif
+    "fildll (%edi)\n"
+    "movl %edi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%edi)\n"
+  );
+}
+void nseel_asm_and_op_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_uplus(void) // this is the same as doing nothing, it seems
+{
+   __asm__(
+      ""
+    );
+}
+void nseel_asm_uplus_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_uminus(void)
+{
+  __asm__(
+#if EEL_F_SIZE == 8
+    "movl (%eax), %ecx\n"
+    "movl 4(%eax), %edi\n"
+    "movl %ecx, (%esi)\n"
+    "xorl $0x80000000, %edi\n"
+    "movl %esi, %eax\n"
+    "movl %edi, 4(%esi)\n"
+    "addl $8, %esi\n"
+#else
+    "movl (%eax), %ecx\n"
+    "xorl $0x80000000, %ecx\n"
+    "movl %esi, %eax\n"
+    "movl %ecx, (%esi)\n"
+    "addl $4, %esi\n"
+#endif
+  );
+}
+void nseel_asm_uminus_end(void) {}
+
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_sign(void)
+{
+  __asm__(
+
+#ifdef TARGET_X64
+
+
+    "movl $0xFFFFFFFF, %rdi\n"
+    "movll (%rax), %rcx\n"
+    "movll $0x7FFFFFFFFFFFFFFF, %rdx\n"
+    "testl %rdx, %rcx\n"
+    "jz 1f\n"
+    "shr $60, %rcx\n"
+    "andl $8, %rcx\n"
+    "addll %rdi, %rcx\n"
+    "movl %rsi, %rax\n"
+    "addl $8, %rsi\n"
+    "movll (%rcx), %rdi\n"
+    "movll %rdi, (%rax)\n"
+	"1:\n"
+   
+
+#else
+
+    "movl $0xFFFFFFFF, %edi\n"
+#if EEL_F_SIZE == 8
+    "movl 4(%eax), %ecx\n"
+    "movl (%eax), %edx\n"
+    "testl $0xFFFFFFFF, %edx\n"
+    "jnz 0f\n"
+#else
+    "movl (%eax), %ecx\n"
+#endif
+    // high dword (minus sign bit) is zero 
+    "test $0x7FFFFFFF, %ecx\n"
+    "jz 1f\n" // zero zero, return the value passed directly
+    "0:\n"
+#if EEL_F_SIZE == 8
+	"shrl $28, %ecx\n"
+#else
+	"shrl $29, %ecx\n"
+#endif
+
+    "andl $" EEL_F_SSTR ", %ecx\n"
+    "addl %edi, %ecx\n"
+
+    "movl %esi, %eax\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+
+    "movl (%ecx), %edi\n"
+#if EEL_F_SIZE == 8
+    "movl 4(%ecx), %edx\n"
+#endif
+    "movl %edi, (%eax)\n"
+#if EEL_F_SIZE == 8
+    "movl %edx, 4(%eax)\n"
+#endif
+	"1:\n"
+   
+#endif
+);
+}
+void nseel_asm_sign_end(void) {}
+
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_bnot(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fabs\n"
+#ifdef TARGET_X64
+    "movl $0xFFFFFFFF, %rax\n"
+    "fcomp" EEL_F_SUFFIX " (%rax)\n" //[g_closefact]
+#else
+    "fcomp" EEL_F_SUFFIX " (0xFFFFFFFF)\n" //[g_closefact]
+#endif
+    "fstsw %ax\n"
+    "test $256, %eax\n"
+    "movl %esi, %eax\n"
+    "jz 0f\n"
+    "fld1\n"
+    "jmp 1f\n"
+    "0:\n"
+    "fldz\n"
+    "1:\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_bnot_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_if(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fabs\n"
+#ifdef TARGET_X64
+    "movl $0xFFFFFFFF, %rax\n"
+    "fcomp" EEL_F_SUFFIX " (%rax)\n" //[g_closefact]
+    "movll $0xFFFFFFFF, %rax\n"
+    "movll %rax, (%esi)\n" // conversion script will extend these out to full len
+    "movll $0xFFFFFFFF, %rax\n"
+    "movll %rax, 8(%esi)\n"
+    "fstsw %ax\n"
+    "shrl $5, %rax\n"
+    "andl $8, %rax\n"
+    "movll (%rax, %rsi), %rax\n"
+    "subl $8, %rsp\n"
+#else
+    "fcomp" EEL_F_SUFFIX " (0xFFFFFFFF)\n" //[g_closefact]
+    "movl $0xFFFFFFFF, (%esi)\n"
+    "movl $0xFFFFFFFF, 4(%esi)\n"
+    "fstsw %ax\n"
+    "shrl $6, %eax\n"
+    "andl $4, %eax\n"
+    "movl (%eax, %esi), %eax\n"
+#endif
+    "call *%eax\n"
+#ifdef TARGET_X64
+    "addl $8, %rsp\n"
+#endif
+
+  );
+}
+void nseel_asm_if_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_repeat(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fistpl (%esi)\n"
+#ifdef TARGET_X64 // safe not sure if movl ecx will zero the high word
+    "xorl %ecx, %ecx\n"
+#endif 
+    "movl (%esi), %ecx\n"
+    "cmpl $1, %ecx\n"
+    "jl 1f\n"
+    "cmpl $" NSEEL_LOOPFUNC_SUPPORT_MAXLEN_STR ", %ecx\n"
+    "jl 0f\n"
+    "movl $" NSEEL_LOOPFUNC_SUPPORT_MAXLEN_STR ", %ecx\n"
+"0:\n"
+      "movl $0xFFFFFFFF, %edx\n"
+      "subl $8, %esp\n" /* keep stack aligned -- note this is required on x64 too!*/ 
+      "pushl %esi\n" // revert back to last temp workspace
+      "pushl %ecx\n"
+      "call *%edx\n"
+      "popl %ecx\n"
+      "popl %esi\n"
+      "addl $8, %esp\n" /* keep stack aligned -- also required on x64*/ 
+    "decl %ecx\n"
+    "jnz 0b\n"
+"1:\n"
+  );
+}
+void nseel_asm_repeat_end(void) {}
+
+void nseel_asm_repeatwhile(void)
+{
+  __asm__(
+    "movl $" NSEEL_LOOPFUNC_SUPPORT_MAXLEN_STR ", %ecx\n"
+"0:\n"
+      "movl $0xFFFFFFFF, %edx\n"
+      "subl $8, %esp\n" /* keep stack aligned -- required on x86 and x64*/ 
+      "pushl %esi\n" // revert back to last temp workspace
+      "pushl %ecx\n"
+      "call *%edx\n"
+      "popl %ecx\n"
+      "popl %esi\n"
+      "addl $8, %esp\n" /* keep stack aligned -- required on x86 and x64 */ 
+      "fld" EEL_F_SUFFIX " (%eax)\n"
+	  "fabs\n"
+#ifdef TARGET_X64
+    "movl $0xFFFFFFFF, %rax\n"
+    "fcomp" EEL_F_SUFFIX " (%rax)\n" //[g_closefact]
+#else
+    "fcomp" EEL_F_SUFFIX " (0xFFFFFFFF)\n" //[g_closefact]
+#endif
+      "fstsw %ax\n"
+	  "testl $256, %eax\n"
+	  "jnz 0f\n"
+    "decl %ecx\n"
+    "jnz 0b\n"
+	"0:\n"
+	"movl %esi, %eax\n"
+  );
+}
+void nseel_asm_repeatwhile_end(void) {}
+
+
+void nseel_asm_band(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fabs\n"
+#ifdef TARGET_X64
+    "movl $0xFFFFFFFF, %rax\n"
+    "fcomp" EEL_F_SUFFIX " (%rax)\n" //[g_closefact]
+#else
+    "fcomp" EEL_F_SUFFIX " (0xFFFFFFFF)\n" //[g_closefact]
+#endif
+    "fstsw %ax\n"
+    "testl $256, %eax\n"
+    "jnz 0f\n" // if Z, then we are nonzero
+
+        "movl $0xFFFFFFFF, %ecx\n"
+#ifdef TARGET_X64
+    "subl $8, %rsp\n"
+#endif
+        "call *%ecx\n"
+#ifdef TARGET_X64
+    "addl $8, %rsp\n"
+#endif
+    	"fld" EEL_F_SUFFIX " (%eax)\n"
+    	"fabs\n"
+#ifdef TARGET_X64
+    "movl $0xFFFFFFFF, %rax\n"
+    "fcomp" EEL_F_SUFFIX " (%rax)\n" //[g_closefact]
+#else
+    "fcomp" EEL_F_SUFFIX " (0xFFFFFFFF)\n" //[g_closefact]
+#endif
+    	"fstsw %ax\n"
+        "testl $256, %eax\n"
+	"jnz 0f\n"
+	"fld1\n"
+	"jmp 1f\n"
+
+"0:\n"
+    "fldz\n"
+"1:\n"
+
+    "movl %esi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_band_end(void) {}
+
+void nseel_asm_bor(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fabs\n"
+#ifdef TARGET_X64
+    "movl $0xFFFFFFFF, %rax\n"
+    "fcomp" EEL_F_SUFFIX " (%rax)\n" //[g_closefact]
+#else
+    "fcomp" EEL_F_SUFFIX " (0xFFFFFFFF)\n" //[g_closefact]
+#endif
+    "fstsw %ax\n"
+    "testl $256, %eax\n"
+    "jz 0f\n" // if Z, then we are nonzero
+
+        "movl $0xFFFFFFFF, %ecx\n"
+#ifdef TARGET_X64
+    "subl $8, %rsp\n"
+#endif
+        "call *%ecx\n"
+#ifdef TARGET_X64
+    "addl $8, %rsp\n"
+#endif
+    	"fld" EEL_F_SUFFIX " (%eax)\n"
+    	"fabs\n"
+#ifdef TARGET_X64
+    "movl $0xFFFFFFFF, %rax\n"
+    "fcomp" EEL_F_SUFFIX " (%rax)\n" //[g_closefact]
+#else
+    "fcomp" EEL_F_SUFFIX " (0xFFFFFFFF)\n" //[g_closefact]
+#endif
+    	"fstsw %ax\n"
+        "testl $256, %eax\n"
+	"jz 0f\n"
+	"fldz\n"
+	"jmp 1f\n"
+
+"0:\n"
+    "fld1\n"
+"1:\n"
+
+    "movl %esi, %eax\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_bor_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_equal(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fsub" EEL_F_SUFFIX " (%edi)\n"
+    "fabs\n"
+#ifdef TARGET_X64
+    "movl $0xFFFFFFFF, %rax\n"
+    "fcomp" EEL_F_SUFFIX " (%rax)\n" //[g_closefact]
+#else
+    "fcomp" EEL_F_SUFFIX " (0xFFFFFFFF)\n" //[g_closefact]
+#endif
+    "fstsw %ax\n"
+    "testl $256, %eax\n"
+    "movl %esi, %eax\n"
+    "jz 0f\n"
+    "fld1\n"
+    "jmp 1f\n"
+    "0:\n"
+    "fldz\n"
+    "1:\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n" 
+  );
+}
+void nseel_asm_equal_end(void) {}
+//
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_notequal(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fsub" EEL_F_SUFFIX " (%edi)\n"
+    "fabs\n"
+#ifdef TARGET_X64
+    "movl $0xFFFFFFFF, %rax\n"
+    "fcomp" EEL_F_SUFFIX " (%rax)\n" //[g_closefact]
+#else
+    "fcomp" EEL_F_SUFFIX " (0xFFFFFFFF)\n" //[g_closefact]
+#endif
+    "fstsw %ax\n"
+    "testl $256, %eax\n"
+    "movl %esi, %eax\n"
+    "jnz 0f\n"
+    "fld1\n"
+    "jmp 1f\n"
+    "0:\n"
+    "fldz\n"
+    "1:\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n" 
+  );
+}
+void nseel_asm_notequal_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_below(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%edi)\n"
+    "fcomp" EEL_F_SUFFIX " (%eax)\n"
+    "fstsw %ax\n"
+    "testl $256, %eax\n"
+    "movl %esi, %eax\n"
+    "jz 0f\n"
+    "fld1\n"
+    "jmp 1f\n"
+    "0:\n"
+    "fldz\n"
+    "1:\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_below_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_beloweq(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fcomp" EEL_F_SUFFIX " (%edi)\n"
+    "fstsw %ax\n"
+    "testl $256, %eax\n"
+    "movl %esi, %eax\n"
+    "jnz 0f\n"
+    "fld1\n"
+    "jmp 1f\n"
+    "0:\n"
+    "fldz\n"
+    "1:\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_beloweq_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void nseel_asm_above(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fcomp" EEL_F_SUFFIX " (%edi)\n"
+    "fstsw %ax\n"
+    "testl $256, %eax\n"
+    "movl %esi, %eax\n"
+    "jz 0f\n"
+    "fld1\n"
+    "jmp 1f\n"
+    "0:\n"
+    "fldz\n"
+    "1:\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_above_end(void) {}
+
+void nseel_asm_aboveeq(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%edi)\n"
+    "fcomp" EEL_F_SUFFIX " (%eax)\n"
+    "fstsw %ax\n"
+    "testl $256, %eax\n"
+    "movl %esi, %eax\n"
+    "jnz 0f\n"
+    "fld1\n"
+    "jmp 1f\n"
+    "0:\n"
+    "fldz\n"
+    "1:\n"
+    "fstp" EEL_F_SUFFIX " (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+  );
+}
+void nseel_asm_aboveeq_end(void) {}
+
+
+
+void nseel_asm_min(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%edi)\n"
+    "fcomp" EEL_F_SUFFIX " (%eax)\n"
+    "pushl %eax\n"
+    "fstsw %ax\n"
+    "testl $256, %eax\n"
+    "popl %eax\n"
+    "jz 0f\n"
+    "movl %edi, %eax\n"
+    "0:\n"
+    );
+
+}
+void nseel_asm_min_end(void) {}
+
+void nseel_asm_max(void)
+{
+  __asm__(
+    "fld" EEL_F_SUFFIX " (%edi)\n"
+    "fcomp" EEL_F_SUFFIX " (%eax)\n"
+    "pushl %eax\n"
+    "fstsw %ax\n"
+    "testl $256, %eax\n"
+    "popl %eax\n"
+    "jnz 0f\n"
+    "movl %edi, %eax\n"
+    "0:\n"
+    );
+}
+void nseel_asm_max_end(void) {}
+
+
+
+
+
+// just generic functions left, yay
+
+
+
+
+void _asm_generic3parm(void)
+{
+  __asm__(
+#ifdef TARGET_X64
+
+#ifdef AMD64ABI
+
+    "movl %rsi, %r15\n"
+    "movl %rdi, %rdx\n" // third parameter = parm
+    "movl $0xFFFFFFFF, %rdi\n" // first parameter= context
+
+    "movl %ecx, %rsi\n" // second parameter = parm
+    "movl %rax, %rcx\n" // fourth parameter = parm
+    "movl $0xffffffff, %rax\n" // call function
+    "subl $128, %rsp\n"
+    "call *%rax\n"
+
+    "movl %r15, %rsi\n"
+    "addl $128, %rsp\n"
+
+#else
+    "movl %ecx, %edx\n" // second parameter = parm
+    "movl $0xFFFFFFFF, %ecx\n" // first parameter= context
+    "movl %rdi, %r8\n" // third parameter = parm
+    "movl %rax, %r9\n" // fourth parameter = parm
+    "movl $0xffffffff, %edi\n" // call function
+    "subl $128, %rsp\n"
+    "call *%edi\n"
+    "addl $128, %rsp\n"
+#endif
+
+#else
+SAVE_STACK
+    "movl $0xFFFFFFFF, %edx\n"
+    "pushl %eax\n" // push parameter
+    "pushl %edi\n" // push parameter
+    "pushl %ecx\n" // push parameter
+    "pushl %edx\n" // push context pointer
+    "movl $0xffffffff, %edi\n"
+    "call *%edi\n"
+    "addl $16, %esp\n"
+RESTORE_STACK
+#endif
+ );
+}
+void _asm_generic3parm_end(void) {}
+
+
+void _asm_generic3parm_retd(void)
+{
+  __asm__(
+#ifdef TARGET_X64
+#ifdef AMD64ABI
+    "movl %rsi, %r15\n"
+    "movl %rdi, %rdx\n" // third parameter = parm
+    "movl $0xFFFFFFFF, %rdi\n" // first parameter= context
+    "movl %ecx, %rsi\n" // second parameter = parm
+    "movl %rax, %rcx\n" // fourth parameter = parm
+    "movl $0xffffffff, %rax\n" // call function
+    "subl $128, %rsp\n"
+    "call *%rax\n"
+    "addl $128, %rsp\n"
+    "movl %r15, %rsi\n"
+    "movl %r15, %rax\n"
+    "movq xmm0, (%r15)\n"
+    "addl $8, %rsi\n"
+#else
+    "movl %ecx, %edx\n" // second parameter = parm
+    "movl $0xFFFFFFFF, %ecx\n" // first parameter= context
+    "movl %rdi, %r8\n" // third parameter = parm
+    "movl %rax, %r9\n" // fourth parameter = parm
+    "movl $0xffffffff, %edi\n" // call function
+    "subl $128, %rsp\n"
+    "call *%edi\n"
+    "addl $128, %rsp\n"
+    "movq xmm0, (%rsi)\n"
+    "movl %rsi, %rax\n"
+    "addl $8, %rsi\n"
+#endif
+#else
+SAVE_STACK
+    "movl $0xFFFFFFFF, %edx\n"
+    "pushl %eax\n" // push parameter
+    "pushl %edi\n" // push parameter
+    "pushl %ecx\n" // push parameter
+    "pushl %edx\n" // push context pointer
+    "movl $0xffffffff, %edi\n"
+    "call *%edi\n"
+    "movl %esi, %eax\n"
+	  "fstp" EEL_F_SUFFIX " (%esi)\n"
+   	"addl $" EEL_F_SSTR ", %esi\n"
+    "addl $16, %esp\n"
+RESTORE_STACK
+#endif
+ );
+}
+void _asm_generic3parm_retd_end(void) {}
+
+
+void _asm_generic2parm(void) // this prob neds to be fixed for ppc
+{
+  __asm__(
+#ifdef TARGET_X64
+
+#ifdef AMD64ABI
+    "movl %rsi, %r15\n"
+    "movl %edi, %esi\n" // second parameter = parm
+    "movl $0xFFFFFFFF, %edi\n" // first parameter= context
+    "movl %rax, %rdx\n" // third parameter = parm
+    "movl $0xffffffff, %rcx\n" // call function
+    "subl $128, %rsp\n"
+    "call *%rcx\n"
+    "movl %r15, %rsi\n"
+    "addl $128, %rsp\n"
+#else
+    "movl $0xFFFFFFFF, %ecx\n" // first parameter= context
+    "movl %edi, %edx\n" // second parameter = parm
+    "movl %rax, %r8\n" // third parameter = parm
+    "movl $0xffffffff, %edi\n" // call function
+    "subl $128, %rsp\n"
+    "call *%edi\n"
+    "addl $128, %rsp\n"
+#endif
+#else
+SAVE_STACK
+    "movl $0xFFFFFFFF, %edx\n"
+    "subl $4, %esp\n" // keep stack aligned
+    "pushl %eax\n" // push parameter
+    "pushl %edi\n" // push parameter
+    "pushl %edx\n" // push context pointer
+    "movl $0xffffffff, %edi\n"
+    "call *%edi\n"
+    "addl $16, %esp\n"
+RESTORE_STACK
+#endif
+ );
+}
+void _asm_generic2parm_end(void) {}
+
+
+void _asm_generic2parm_retd(void)
+{
+  __asm__(
+#ifdef TARGET_X64
+#ifdef AMD64ABI
+    "movl %rsi, %r15\n"
+    "movl %rdi, %rsi\n" // second parameter = parm
+    "movl $0xFFFFFFFF, %rdi\n" // first parameter= context
+    "movl %rax, %rdx\n" // third parameter = parm
+    "movl $0xffffffff, %rcx\n" // call function
+    "subl $128, %rsp\n"
+    "call *%rcx\n"
+    "movl %r15, %rsi\n"
+    "addl $128, %rsp\n"
+    "movq xmm0, (%r15)\n"
+    "movl %r15, %rax\n"
+    "addl $8, %rsi\n"
+#else
+    "movl $0xFFFFFFFF, %ecx\n" // first parameter= context
+    "movl %edi, %edx\n" // second parameter = parm
+    "movl %rax, %r8\n" // third parameter = parm
+    "movl $0xffffffff, %edi\n" // call function
+    "subl $128, %rsp\n"
+    "call *%edi\n"
+    "addl $128, %rsp\n"
+    "movq xmm0, (%rsi)\n"
+    "movl %rsi, %rax\n"
+    "addl $8, %rsi\n"
+#endif
+#else
+SAVE_STACK
+    "movl $0xFFFFFFFF, %edx\n"
+    "pushl %eax\n" // push parameter
+    "pushl %edi\n" // push parameter
+    "pushl %ecx\n" // push parameter
+    "pushl %edx\n" // push context pointer
+    "movl $0xffffffff, %edi\n"
+    "call *%edi\n"
+    "movl %esi, %eax\n"
+	  "fstp" EEL_F_SUFFIX " (%esi)\n"
+   	"addl $" EEL_F_SSTR ", %esi\n"
+    "addl $16, %esp\n"
+RESTORE_STACK
+#endif
+ );
+}
+void _asm_generic2parm_retd_end(void) {}
+
+
+
+
+
+void _asm_generic1parm(void) // this prob neds to be fixed for ppc
+{
+  __asm__(
+#ifdef TARGET_X64
+#ifdef AMD64ABI
+    "movl $0xFFFFFFFF, %rdi\n" // first parameter= context
+    "movl %rsi, %r15\n"
+    "movl %eax, %rsi\n" // second parameter = parm
+    "subl $128, %rsp\n"
+    "movl $0xffffffff, %rcx\n" // call function
+    "call *%rcx\n"
+    "movl %r15, %rsi\n"
+    "addl $128, %rsp\n"
+#else
+    "movl $0xFFFFFFFF, %ecx\n" // first parameter= context
+    "movl %eax, %edx\n" // second parameter = parm
+    "movl $0xffffffff, %edi\n" // call function
+    "subl $128, %rsp\n"
+    "call *%edi\n"
+    "addl $128, %rsp\n"
+#endif
+#else
+SAVE_STACK
+    "movl $0xFFFFFFFF, %edx\n"
+    "subl $8, %esp\n" // keep stack aligned
+    "pushl %eax\n" // push parameter
+    "pushl %edx\n" // push context pointer
+    "movl $0xffffffff, %edi\n"
+    "call *%edi\n"
+    "addl $16, %esp\n"
+RESTORE_STACK
+#endif
+
+ );
+}
+void _asm_generic1parm_end(void) {}
+
+
+void _asm_generic1parm_retd(void) // 1 parameter returning double
+{
+  __asm__(
+#ifdef TARGET_X64
+#ifdef AMD64ABI
+    "movl %rsi, %r15\n"
+    "movl $0xFFFFFFFF, %rdi\n" // first parameter= context
+    "movl %rax, %rsi\n" // second parameter = parm
+    "movl $0xffffffff, %rcx\n" // call function
+    "subl $128, %rsp\n"
+    "call *%rcx\n"
+    "movl %r15, %rsi\n"
+    "addl $128, %rsp\n"
+    "movq xmm0, (%r15)\n"
+    "movl %r15, %rax\n"
+    "addl $8, %rsi\n"
+#else
+    "movl $0xFFFFFFFF, %ecx\n" // first parameter= context
+    "movl %eax, %edx\n" // second parameter = parm
+    "movl $0xffffffff, %edi\n" // call function
+    "subl $128, %rsp\n"
+    "call *%edi\n"
+    "addl $128, %rsp\n"
+    "movq xmm0, (%rsi)\n"
+    "movl %rsi, %rax\n"
+    "addl $8, %rsi\n"
+#endif
+#else
+SAVE_STACK
+    "movl $0xFFFFFFFF, %edx\n"
+    "subl $8, %esp\n" // keep stack aligned
+    "pushl %eax\n" // push parameter
+    "pushl %edx\n" // push context pointer
+    "movl $0xffffffff, %edi\n"
+    "call *%edi\n"
+	  "movl %esi, %eax\n"
+	  "fstp" EEL_F_SUFFIX " (%esi)\n"
+	  "addl $" EEL_F_SSTR ", %esi\n"
+    "addl $16, %esp\n"
+RESTORE_STACK
+#endif
+ );
+}
+void _asm_generic1parm_retd_end(void) {}
+
+
+
+
+
+// this gets its own stub because it's pretty crucial for performance :/
+
+void _asm_megabuf(void)
+{
+  __asm__(
+SAVE_STACK
+
+#ifdef TARGET_X64
+
+
+#ifdef AMD64ABI
+
+    "movl %rsi, %r15\n"
+    "movl $0xFFFFFFFF, %rdi\n" // first parameter = context pointer
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "movl $0xFFFFFFFF, %rdx\n"
+    "fadd" EEL_F_SUFFIX " (%rdx)\n"
+    "fistpl (%r15)\n"
+    "xorl %rsi, %rsi\n"
+    "movl (%r15), %esi\n" // r15 = esi (from above)
+    "movl $0xffffffff, %edx\n"
+    "subl $128, %rsp\n"
+    "call *%edx\n"
+    "movl %r15, %rsi\n"
+    "addl $128, %rsp\n"
+    "and %rax, %rax\n"
+    "jnz 0f\n"
+    "movl %r15, %rax\n"
+    "movll $0, (%esi)\n"
+    "addl $" EEL_F_SSTR ", %rsi\n"
+    "0:"
+
+#else
+    "movl $0xFFFFFFFF, %ecx\n" // first parameter = context pointer
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+	"movl $0xFFFFFFFF, %edx\n"
+    "fadd" EEL_F_SUFFIX " (%rdx)\n"
+    "fistpl (%esi)\n"
+    "xorl %rdx, %rdx\n"
+    "movl (%esi), %edx\n"
+    "movl $0xffffffff, %edi\n"
+	"subl $128, %rsp\n"
+    "call *%edi\n"
+	"addl $128, %rsp\n"
+    "and %rax, %rax\n"
+    "jnz 0f\n"
+    "movl %rsi, %rax\n"
+    "movll $0, (%esi)\n"
+    "addl $" EEL_F_SSTR ", %esi\n"
+    "0:"
+#endif
+
+
+#else
+    "movl $0xFFFFFFFF, %edx\n"
+    "fld" EEL_F_SUFFIX " (%eax)\n"
+    "fadd" EEL_F_SUFFIX " (0xFFFFFFFF)\n"
+    "fistpl (%esi)\n"
+    "subl $8, %esp\n" // keep stack aligned
+    "pushl (%esi)\n" // parameter
+    "pushl %edx\n" // push context pointer
+    "movl $0xffffffff, %edi\n"
+    "call *%edi\n"
+    "addl $16, %esp\n"
+    "and %eax, %eax\n"
+    "jnz 0f\n"
+    "movl %esi, %eax\n"
+    "movl $0, (%esi)\n"
+#if EEL_F_SIZE == 8
+    "movl $0, 4(%esi)\n"
+#endif
+    "addl $" EEL_F_SSTR ", %esi\n"
+    "0:"
+
+
+#endif
+
+RESTORE_STACK
+
+ );
+}
+
+void _asm_megabuf_end(void) {}
+
+
+#ifdef TARGET_X64
+void win64_callcode() 
+{
+	__asm__(
+#ifdef AMD64ABI
+		"movll %edi, %eax\n"
+#else
+		"movll %ecx, %eax\n"
+#endif
+
+		"push %rbx\n"
+		"push %rbp\n"
+#ifndef AMD64ABI
+		"push %rdi\n"
+		"push %rsi\n"
+		"push %r12\n"
+		"push %r13\n"
+#endif
+		"push %r14\n" // on AMD64ABI, we'll use r14/r15 to save edi/esi
+		"push %r15\n"
+		"call %eax\n"
+		"pop %r15\n"
+		"pop %r14\n"
+#ifndef AMD64ABI
+		"pop %r13\n"
+		"pop %r12\n"
+		"pop %rsi\n"
+		"pop %rdi\n"
+		"fclex\n"
+#endif
+		"pop %rbp\n"
+		"pop %rbx\n"
+		"ret\n"
+	);
+}
+
+#endif
\ No newline at end of file
diff --git a/Src/Plugins/Visualization/vis_milk2/ns-eel2/asm-nseel-x86-msvc.c b/Src/Plugins/Visualization/vis_milk2/ns-eel2/asm-nseel-x86-msvc.c
new file mode 100644
index 00000000..30c88c5c
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_milk2/ns-eel2/asm-nseel-x86-msvc.c
@@ -0,0 +1,2463 @@
+// THIS FILE AUTOGENERATED FROM asm-nseel-x86-gcc.c by a2i.php
+
+#if EEL_F_SIZE == 8
+  #define EEL_ASM_TYPE qword ptr
+#else
+  #define EEL_ASM_TYPE dword ptr
+#endif
+
+#if defined(__APPLE__)
+#define SAVE_STACK "pushl %ebp\nmovl %esp, %ebp\nandl $-16, %esp\n"
+#define RESTORE_STACK "leave\n"
+#else
+#define SAVE_STACK
+#define RESTORE_STACK
+#endif
+
+/* note: only EEL_F_SIZE=8 is now supported (no float EEL_F's) */
+
+__declspec(naked) void nseel_asm_1pdd(void)
+{
+  __asm {
+	  SAVE_STACK
+#ifdef TARGET_X64
+      movq xmm0, [eax];
+	  sub rsp, 128;
+     mov edi, 0xffffffff;
+#ifdef AMD64ABI
+     mov r15, rsi;
+     call edi;
+     mov rsi, r15;
+     movq [r15], xmm0;
+#else
+     call edi;
+     movq [esi], xmm0;
+#endif
+     add rsp, 128;
+#else
+              sub esp, 8; /* keep stack aligned */
+					    push dword ptr [eax+4]; /* push parameter */
+					    push dword ptr [eax];    /* push the rest of the parameter */
+              mov edi, 0xffffffff;
+					    call edi;
+					    fstp qword ptr [esi]; /* store result */
+					    add esp, 16;
+#endif
+					    mov eax, esi; /* set return value */
+					    add esi, 8; /* advance worktab ptr */
+  	RESTORE_STACK
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_1pdd_end(void){}
+
+__declspec(naked) void nseel_asm_2pdd(void)
+{
+  __asm {
+	SAVE_STACK
+#ifdef TARGET_X64
+    movq xmm1, [eax];
+    movq xmm0, [edi];
+	sub rsp, 128;
+    mov edi, 0xffffffff;
+#ifdef AMD64ABI
+    mov r15, rsi;
+    call edi;
+    mov rsi, r15;
+    movq [r15], xmm0;
+#else
+    call edi;
+    movq [esi], xmm0;
+#endif
+    add rsp, 128;
+#else
+					    push dword ptr [eax+4]; /* push parameter */
+					    push dword ptr [eax];    /* push the rest of the parameter */
+					    push dword ptr [edi+4]; /* push parameter */
+					    push dword ptr [edi];    /* push the rest of the parameter */
+              mov edi, 0xffffffff;
+					    call edi;
+					    fstp qword ptr [esi]; /* store result */
+					    add esp, 16;
+#endif
+					    mov eax, esi; /* set return value */
+					    add esi, 8; /* advance worktab ptr */
+	RESTORE_STACK
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_2pdd_end(void){}
+
+__declspec(naked) void nseel_asm_2pdds(void)
+{
+  __asm {
+	SAVE_STACK
+#ifdef TARGET_X64
+    movq xmm1, [eax];
+    movq xmm0, [edi];
+	sub rsp, 128;
+    mov eax, 0xffffffff;
+#ifdef AMD64ABI
+    mov r15, rsi;
+    mov r14, rdi;
+    call eax;
+    mov rsi, r15;
+    movq [r14], xmm0;
+    mov rax, r14; /* set return value */
+#else
+    call eax;
+    movq [edi], xmm0;
+    mov eax, edi; /* set return value */
+#endif
+    sub rsp, 128;
+#else
+					    push dword ptr [eax+4]; /* push parameter */
+					    push dword ptr [eax];    /* push the rest of the parameter */
+					    push dword ptr [edi+4]; /* push parameter */
+					    push dword ptr [edi];    /* push the rest of the parameter */
+              mov eax, 0xffffffff;
+					    call eax;
+					    fstp qword ptr [edi]; /* store result */
+					    add esp, 16;
+    mov eax, edi; /* set return value */
+#endif
+RESTORE_STACK
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_2pdds_end(void){}
+
+__declspec(naked) void nseel_asm_2pp(void)
+{
+    __asm {
+SAVE_STACK
+#ifdef TARGET_X64
+
+#ifdef AMD64ABI
+    mov r15, rsi;
+    /* rdi is first parameter */
+    mov rsi, rax;
+    sub rsp, 128;
+              mov eax, 0xffffffff;
+					    call eax;
+    mov rsi, r15;
+    movq [r15], xmm0;
+#else
+              mov ecx, edi;
+              mov edx, eax;
+              sub rsp, 128;
+    mov edi, 0xffffffff;
+    call edi;
+    movq [esi], xmm0;
+#endif
+    add rsp, 128;
+#else
+              sub esp, 8; /* keep stack aligned */
+              push eax; /* push parameter */
+					    push edi;    /* push second parameter */
+              mov edi, 0xffffffff;
+					    call edi;
+					    fstp EEL_ASM_TYPE [esi]; /* store result */
+					    add esp, 16;
+#endif
+					    mov eax, esi; /* set return value */
+					    add esi, EEL_F_SIZE; /* advance worktab ptr */
+RESTORE_STACK
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_2pp_end(void) {}
+
+
+__declspec(naked) void nseel_asm_1pp(void)
+{
+__asm {
+SAVE_STACK
+#ifdef TARGET_X64
+#ifdef AMD64ABI
+    mov r15, rsi;
+    mov edi, eax;
+    sub rsp, 128;
+    mov rax, 0xffffffff;
+    call rax;
+    mov rsi, r15;
+    movq [r15], xmm0;
+#else
+              mov ecx, eax;
+              sub rsp, 128;
+    mov edi, 0xffffffff;
+    call edi;
+    movq [esi], xmm0;
+#endif
+    add rsp, 128;
+#else
+              sub esp, 12; /* keep stack aligned */
+					    push eax; /* push parameter */
+              mov edi, 0xffffffff;
+              call edi;
+					    fstp EEL_ASM_TYPE [esi]; /* store result */
+					    add esp, 16;
+#endif
+					    mov eax, esi; /* set return value */
+					    add esi, EEL_F_SIZE; /* advance worktab ptr */
+RESTORE_STACK
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_1pp_end(void){}
+
+
+
+//---------------------------------------------------------------------------------------------------------------
+
+
+// do nothing, eh
+__declspec(naked) void nseel_asm_exec2(void)
+{
+   __asm {
+      
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+    }
+}
+__declspec(naked) void nseel_asm_exec2_end(void) { }
+
+
+
+__declspec(naked) void nseel_asm_invsqrt(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    mov edx, 0x5f3759df;
+    fst dword ptr [esi];
+#ifdef TARGET_X64
+    mov rax, 0xffffffff;
+    sub ecx, ecx;
+    fmul EEL_ASM_TYPE [rax];
+#else
+#if EEL_F_SIZE == 8
+_emit 0xDC; // fmul qword ptr [0xffffffff]
+_emit 0x0D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#else
+_emit 0xD8; // fmul dword ptr [0xffffffff]
+_emit 0x0D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#endif
+#endif
+    mov ecx, dword ptr [esi];
+    sar ecx, 1;
+    sub edx, ecx;
+    mov dword ptr [esi], edx;
+    fmul dword ptr [esi];
+    fmul dword ptr [esi];
+#ifdef TARGET_X64
+    mov rax, 0xffffffff;
+    fadd EEL_ASM_TYPE [rax];
+#else
+#if EEL_F_SIZE == 8
+_emit 0xDC; // fadd qword ptr [0xffffffff]
+_emit 0x05;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#else
+_emit 0xD8; // fadd dword ptr [0xffffffff]
+_emit 0x05;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#endif
+#endif
+    fmul dword ptr [esi];
+    mov eax, esi;
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_invsqrt_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_sin(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fsin;
+    mov eax, esi;
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_sin_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_cos(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fcos;
+    mov eax, esi;
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_cos_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_tan(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fptan;
+    mov eax, esi;
+    fstp st(0);
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_tan_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_sqr(void)
+{
+  __asm {
+	fld EEL_ASM_TYPE [eax];
+    fmul st(0), st(0);
+    mov eax, esi;
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_sqr_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_sqrt(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fabs;
+    fsqrt;
+    mov eax, esi;
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_sqrt_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_log(void)
+{
+  __asm {
+    fldln2;
+    fld EEL_ASM_TYPE [eax];
+    mov eax, esi;
+    fyl2x;
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_log_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_log10(void)
+{
+  __asm {
+    fldlg2;
+    fld EEL_ASM_TYPE [eax];
+    mov eax, esi;
+    fyl2x;
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_log10_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_abs(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fabs;
+    mov eax, esi;
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_abs_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_assign(void)
+{
+#ifdef TARGET_X64
+
+  __asm {
+    mov rdx, qword ptr [rax];
+    mov rcx, rdx;
+    shr rdx, 32;
+    and edx, 0x7FF00000;
+    jz label_0;
+    cmp edx, 0x7FF00000;
+    je label_0;
+    jmp label_1;
+label_0:
+    
+    sub rcx, rcx;
+label_1:
+    
+    mov qword ptr [edi], rcx;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+    }
+
+#else
+
+
+#if EEL_F_SIZE == 8
+  __asm {
+    mov edx, dword ptr [eax+4];
+    mov ecx, dword ptr [eax];
+    and edx, 0x7ff00000;
+    jz label_2;   // if exponent=zero, zero
+    cmp edx, 0x7ff00000;
+    je label_2; // if exponent=all 1s, zero
+    mov edx, dword ptr [eax+4]; // reread
+    jmp label_3;
+label_2:
+    
+    sub ecx, ecx;
+    sub edx, edx;
+label_3:
+    
+    mov dword ptr [edi], ecx;
+    mov dword ptr [edi+4], edx;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+#else
+  __asm {
+    mov ecx, dword ptr [eax];
+    mov dword ptr [edi], ecx;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+#endif
+
+#endif
+
+}
+__declspec(naked) void nseel_asm_assign_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_add(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fadd EEL_ASM_TYPE [edi];
+    mov eax, esi;
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_add_end(void) {}
+
+__declspec(naked) void nseel_asm_add_op(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fadd EEL_ASM_TYPE [edi];
+    mov eax, edi;
+    fstp EEL_ASM_TYPE [edi];
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_add_op_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_sub(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [edi];
+    fsub EEL_ASM_TYPE [eax];
+    mov eax, esi;
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_sub_end(void) {}
+
+__declspec(naked) void nseel_asm_sub_op(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [edi];
+    fsub EEL_ASM_TYPE [eax];
+    mov eax, edi;
+    fstp EEL_ASM_TYPE [edi];
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_sub_op_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_mul(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [edi];
+    fmul EEL_ASM_TYPE [eax];
+    mov eax, esi;
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_mul_end(void) {}
+
+__declspec(naked) void nseel_asm_mul_op(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fmul EEL_ASM_TYPE [edi];
+    mov eax, edi;
+    fstp EEL_ASM_TYPE [edi];
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_mul_op_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_div(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [edi];
+    fdiv EEL_ASM_TYPE [eax];
+    mov eax, esi;
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_div_end(void) {}
+
+__declspec(naked) void nseel_asm_div_op(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [edi];
+    fdiv EEL_ASM_TYPE [eax];
+    mov eax, edi;
+    fstp EEL_ASM_TYPE [edi];
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_div_op_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_mod(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [edi];
+    fld EEL_ASM_TYPE [eax];
+    fabs;
+    fistp dword ptr [esi];
+    fabs;
+    fistp dword ptr [esi+4];
+    xor edx, edx;
+#ifdef TARGET_X64
+    sub eax, eax;
+#endif
+    cmp dword ptr [esi], 0;
+    je label_4; // skip devide, set return to 0
+    mov eax, dword ptr [esi+4];
+    div dword ptr [esi];
+label_4:
+    
+    mov dword ptr [esi], edx;
+    fild dword ptr [esi];
+    mov eax, esi;
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_mod_end(void) {}
+
+__declspec(naked) void nseel_asm_mod_op(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [edi];
+    fld EEL_ASM_TYPE [eax];
+    fabs;
+    fistp dword ptr [edi];
+    fabs;
+    fistp dword ptr [esi];
+#ifdef TARGET_X64
+    sub eax, eax;
+#endif
+    xor edx, edx;
+    cmp dword ptr [edi], 0;
+    je label_5; // skip devide, set return to 0
+    mov eax, dword ptr [esi];
+    div dword ptr [edi];
+label_5:
+    
+    mov dword ptr [edi], edx;
+    fild dword ptr [edi];
+    mov eax, edi;
+    fstp EEL_ASM_TYPE [edi];
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+    }
+}
+__declspec(naked) void nseel_asm_mod_op_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_or(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [edi];
+    fld EEL_ASM_TYPE [eax];
+    mov eax, esi;
+    fistp qword ptr [esi];
+    fistp qword ptr [esi+8];
+#ifdef TARGET_X64
+    mov rdi, qword ptr [rsi+8];
+    or qword ptr [rsi], rdi;
+#else
+    mov edi, dword ptr [esi+8];
+    mov ecx, dword ptr [esi+12];
+    or dword ptr [esi], edi;
+    or dword ptr [esi+4], ecx;
+#endif
+    fild qword ptr [esi];
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_or_end(void) {}
+
+__declspec(naked) void nseel_asm_or_op(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [edi];
+    fld EEL_ASM_TYPE [eax];
+    fistp qword ptr [edi];
+    fistp qword ptr [esi];
+#ifdef TARGET_X64
+    mov rax, qword ptr [rsi];
+    or qword ptr [rdi], rax;
+#else
+    mov eax, dword ptr [esi];
+    mov ecx, dword ptr [esi+4];
+    or dword ptr [edi], eax;
+    or dword ptr [edi+4], ecx;
+#endif
+    fild qword ptr [edi];
+    mov eax, edi;
+    fstp EEL_ASM_TYPE [edi];
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_or_op_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_and(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [edi];
+    fld EEL_ASM_TYPE [eax];
+    mov eax, esi;
+    fistp qword ptr [esi];
+    fistp qword ptr [esi+8];
+#ifdef TARGET_X64
+    mov rdi, qword ptr [rsi+8];
+    and qword ptr [rsi], rdi;
+#else
+    mov edi, dword ptr [esi+8];
+    mov ecx, dword ptr [esi+12];
+    and dword ptr [esi], edi;
+    and dword ptr [esi+4], ecx;
+#endif
+    fild qword ptr [esi];
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_and_end(void) {}
+
+__declspec(naked) void nseel_asm_and_op(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [edi];
+    fld EEL_ASM_TYPE [eax];
+    fistp qword ptr [edi];
+    fistp qword ptr [esi];
+#ifdef TARGET_X64
+    mov rax, qword ptr [rsi];
+    and qword ptr [rdi], rax;
+#else
+    mov eax, dword ptr [esi];
+    mov ecx, dword ptr [esi+4];
+    and dword ptr [edi], eax;
+    and dword ptr [edi+4], ecx;
+#endif
+    fild qword ptr [edi];
+    mov eax, edi;
+    fstp EEL_ASM_TYPE [edi];
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_and_op_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_uplus(void) // this is the same as doing nothing, it seems
+{
+   __asm {
+      
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+    }
+}
+__declspec(naked) void nseel_asm_uplus_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_uminus(void)
+{
+  __asm {
+#if EEL_F_SIZE == 8
+    mov ecx, dword ptr [eax];
+    mov edi, dword ptr [eax+4];
+    mov dword ptr [esi], ecx;
+    xor edi, 0x80000000;
+    mov eax, esi;
+    mov dword ptr [esi+4], edi;
+    add esi, 8;
+#else
+    mov ecx, dword ptr [eax];
+    xor ecx, 0x80000000;
+    mov eax, esi;
+    mov dword ptr [esi], ecx;
+    add esi, 4;
+#endif
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_uminus_end(void) {}
+
+
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_sign(void)
+{
+  __asm {
+
+#ifdef TARGET_X64
+
+
+    mov rdi, 0xFFFFFFFF;
+    mov rcx, qword ptr [rax];
+    mov rdx, 0x7FFFFFFFFFFFFFFF;
+    test rcx, rdx;
+    jz label_6;
+    shr rcx, 60;
+    and rcx, 8;
+    add rcx, rdi;
+    mov rax, rsi;
+    add rsi, 8;
+    mov rdi, qword ptr [rcx];
+    mov qword ptr [rax], rdi;
+label_6:
+	
+
+
+#else
+
+    mov edi, 0xFFFFFFFF;
+#if EEL_F_SIZE == 8
+    mov ecx, dword ptr [eax+4];
+    mov edx, dword ptr [eax];
+    test edx, 0xFFFFFFFF;
+    jnz label_7;
+#else
+    mov ecx, dword ptr [eax];
+#endif
+    // high dword (minus sign bit) is zero
+    test ecx, 0x7FFFFFFF;
+    jz label_8; // zero zero, return the value passed directly
+label_7:
+    
+#if EEL_F_SIZE == 8
+	shr ecx, 28;
+#else
+	shr ecx, 29;
+#endif
+
+    and ecx, EEL_F_SIZE;
+    add ecx, edi;
+
+    mov eax, esi;
+    add esi, EEL_F_SIZE;
+
+    mov edi, dword ptr [ecx];
+#if EEL_F_SIZE == 8
+    mov edx, dword ptr [ecx+4];
+#endif
+    mov dword ptr [eax], edi;
+#if EEL_F_SIZE == 8
+    mov dword ptr [eax+4], edx;
+#endif
+label_8:
+	
+
+#endif
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+}
+}
+__declspec(naked) void nseel_asm_sign_end(void) {}
+
+
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_bnot(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fabs;
+#ifdef TARGET_X64
+    mov rax, 0xFFFFFFFF;
+    fcomp EEL_ASM_TYPE [rax]; //[g_closefact]
+#else
+#if EEL_F_SIZE == 8
+_emit 0xDC; // fcomp qword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#else
+_emit 0xD8; // fcomp dword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#endif
+#endif
+    fstsw ax;
+    test eax, 256;
+    mov eax, esi;
+    jz label_9;
+    fld1;
+    jmp label_10;
+label_9:
+    
+    fldz;
+label_10:
+    
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_bnot_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_if(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fabs;
+#ifdef TARGET_X64
+    mov rax, 0xFFFFFFFF;
+    fcomp EEL_ASM_TYPE [rax]; //[g_closefact]
+    mov rax, 0xFFFFFFFF;
+    mov qword ptr [esi], rax; // conversion script will extend these out to full len
+    mov rax, 0xFFFFFFFF;
+    mov qword ptr [esi+8], rax;
+    fstsw ax;
+    shr rax, 5;
+    and rax, 8;
+    mov rax, qword ptr [rax+rsi];
+    sub rsp, 8;
+#else
+#if EEL_F_SIZE == 8
+_emit 0xDC; // fcomp qword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#else
+_emit 0xD8; // fcomp dword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#endif
+    mov dword ptr [esi], 0xFFFFFFFF;
+    mov dword ptr [esi+4], 0xFFFFFFFF;
+    fstsw ax;
+    shr eax, 6;
+    and eax, 4;
+    mov eax, dword ptr [eax+esi];
+#endif
+    call eax;
+#ifdef TARGET_X64
+    add rsp, 8;
+#endif
+
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_if_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_repeat(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fistp dword ptr [esi];
+#ifdef TARGET_X64 // safe not sure if movl ecx will zero the high word
+    xor ecx, ecx;
+#endif
+    mov ecx, dword ptr [esi];
+    cmp ecx, 1;
+    jl label_11;
+    cmp ecx, NSEEL_LOOPFUNC_SUPPORT_MAXLEN;
+    jl label_12;
+    mov ecx, NSEEL_LOOPFUNC_SUPPORT_MAXLEN;
+label_12:
+
+      mov edx, 0xFFFFFFFF;
+      sub esp, 8; /* keep stack aligned -- note this is required on x64 too!*/
+      push esi; // revert back to last temp workspace
+      push ecx;
+      call edx;
+      pop ecx;
+      pop esi;
+      add esp, 8; /* keep stack aligned -- also required on x64*/
+    dec ecx;
+    jnz label_12;
+label_11:
+
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_repeat_end(void) {}
+
+__declspec(naked) void nseel_asm_repeatwhile(void)
+{
+  __asm {
+    mov ecx, NSEEL_LOOPFUNC_SUPPORT_MAXLEN;
+label_13:
+
+      mov edx, 0xFFFFFFFF;
+      sub esp, 8; /* keep stack aligned -- required on x86 and x64*/
+      push esi; // revert back to last temp workspace
+      push ecx;
+      call edx;
+      pop ecx;
+      pop esi;
+      add esp, 8; /* keep stack aligned -- required on x86 and x64 */
+      fld EEL_ASM_TYPE [eax];
+	  fabs;
+#ifdef TARGET_X64
+    mov rax, 0xFFFFFFFF;
+    fcomp EEL_ASM_TYPE [rax]; //[g_closefact]
+#else
+#if EEL_F_SIZE == 8
+_emit 0xDC; // fcomp qword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#else
+_emit 0xD8; // fcomp dword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#endif
+#endif
+      fstsw ax;
+	  test eax, 256;
+	  jnz label_14;
+    dec ecx;
+    jnz label_13;
+label_14:
+	
+	mov eax, esi;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_repeatwhile_end(void) {}
+
+
+__declspec(naked) void nseel_asm_band(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fabs;
+#ifdef TARGET_X64
+    mov rax, 0xFFFFFFFF;
+    fcomp EEL_ASM_TYPE [rax]; //[g_closefact]
+#else
+#if EEL_F_SIZE == 8
+_emit 0xDC; // fcomp qword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#else
+_emit 0xD8; // fcomp dword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#endif
+#endif
+    fstsw ax;
+    test eax, 256;
+    jnz label_15; // if Z, then we are nonzero
+
+        mov ecx, 0xFFFFFFFF;
+#ifdef TARGET_X64
+    sub rsp, 8;
+#endif
+        call ecx;
+#ifdef TARGET_X64
+    add rsp, 8;
+#endif
+    	fld EEL_ASM_TYPE [eax];
+    	fabs;
+#ifdef TARGET_X64
+    mov rax, 0xFFFFFFFF;
+    fcomp EEL_ASM_TYPE [rax]; //[g_closefact]
+#else
+#if EEL_F_SIZE == 8
+_emit 0xDC; // fcomp qword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#else
+_emit 0xD8; // fcomp dword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#endif
+#endif
+    	fstsw ax;
+        test eax, 256;
+	jnz label_15;
+	fld1;
+	jmp label_16;
+
+label_15:
+
+    fldz;
+label_16:
+
+
+    mov eax, esi;
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_band_end(void) {}
+
+__declspec(naked) void nseel_asm_bor(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fabs;
+#ifdef TARGET_X64
+    mov rax, 0xFFFFFFFF;
+    fcomp EEL_ASM_TYPE [rax]; //[g_closefact]
+#else
+#if EEL_F_SIZE == 8
+_emit 0xDC; // fcomp qword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#else
+_emit 0xD8; // fcomp dword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#endif
+#endif
+    fstsw ax;
+    test eax, 256;
+    jz label_17; // if Z, then we are nonzero
+
+        mov ecx, 0xFFFFFFFF;
+#ifdef TARGET_X64
+    sub rsp, 8;
+#endif
+        call ecx;
+#ifdef TARGET_X64
+    add rsp, 8;
+#endif
+    	fld EEL_ASM_TYPE [eax];
+    	fabs;
+#ifdef TARGET_X64
+    mov rax, 0xFFFFFFFF;
+    fcomp EEL_ASM_TYPE [rax]; //[g_closefact]
+#else
+#if EEL_F_SIZE == 8
+_emit 0xDC; // fcomp qword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#else
+_emit 0xD8; // fcomp dword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#endif
+#endif
+    	fstsw ax;
+        test eax, 256;
+	jz label_17;
+	fldz;
+	jmp label_18;
+
+label_17:
+
+    fld1;
+label_18:
+
+
+    mov eax, esi;
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_bor_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_equal(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fsub EEL_ASM_TYPE [edi];
+    fabs;
+#ifdef TARGET_X64
+    mov rax, 0xFFFFFFFF;
+    fcomp EEL_ASM_TYPE [rax]; //[g_closefact]
+#else
+#if EEL_F_SIZE == 8
+_emit 0xDC; // fcomp qword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#else
+_emit 0xD8; // fcomp dword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#endif
+#endif
+    fstsw ax;
+    test eax, 256;
+    mov eax, esi;
+    jz label_19;
+    fld1;
+    jmp label_20;
+label_19:
+    
+    fldz;
+label_20:
+    
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_equal_end(void) {}
+//
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_notequal(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fsub EEL_ASM_TYPE [edi];
+    fabs;
+#ifdef TARGET_X64
+    mov rax, 0xFFFFFFFF;
+    fcomp EEL_ASM_TYPE [rax]; //[g_closefact]
+#else
+#if EEL_F_SIZE == 8
+_emit 0xDC; // fcomp qword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#else
+_emit 0xD8; // fcomp dword ptr [0xffffffff]
+_emit 0x1D;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#endif
+#endif
+    fstsw ax;
+    test eax, 256;
+    mov eax, esi;
+    jnz label_21;
+    fld1;
+    jmp label_22;
+label_21:
+    
+    fldz;
+label_22:
+    
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_notequal_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_below(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [edi];
+    fcomp EEL_ASM_TYPE [eax];
+    fstsw ax;
+    test eax, 256;
+    mov eax, esi;
+    jz label_23;
+    fld1;
+    jmp label_24;
+label_23:
+    
+    fldz;
+label_24:
+    
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_below_end(void) {}
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_beloweq(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fcomp EEL_ASM_TYPE [edi];
+    fstsw ax;
+    test eax, 256;
+    mov eax, esi;
+    jnz label_25;
+    fld1;
+    jmp label_26;
+label_25:
+    
+    fldz;
+label_26:
+    
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_beloweq_end(void) {}
+
+
+//---------------------------------------------------------------------------------------------------------------
+__declspec(naked) void nseel_asm_above(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [eax];
+    fcomp EEL_ASM_TYPE [edi];
+    fstsw ax;
+    test eax, 256;
+    mov eax, esi;
+    jz label_27;
+    fld1;
+    jmp label_28;
+label_27:
+    
+    fldz;
+label_28:
+    
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_above_end(void) {}
+
+__declspec(naked) void nseel_asm_aboveeq(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [edi];
+    fcomp EEL_ASM_TYPE [eax];
+    fstsw ax;
+    test eax, 256;
+    mov eax, esi;
+    jnz label_29;
+    fld1;
+    jmp label_30;
+label_29:
+    
+    fldz;
+label_30:
+    
+    fstp EEL_ASM_TYPE [esi];
+    add esi, EEL_F_SIZE;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+  }
+}
+__declspec(naked) void nseel_asm_aboveeq_end(void) {}
+
+
+
+__declspec(naked) void nseel_asm_min(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [edi];
+    fcomp EEL_ASM_TYPE [eax];
+    push eax;
+    fstsw ax;
+    test eax, 256;
+    pop eax;
+    jz label_31;
+    mov eax, edi;
+label_31:
+    
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+    }
+
+}
+__declspec(naked) void nseel_asm_min_end(void) {}
+
+__declspec(naked) void nseel_asm_max(void)
+{
+  __asm {
+    fld EEL_ASM_TYPE [edi];
+    fcomp EEL_ASM_TYPE [eax];
+    push eax;
+    fstsw ax;
+    test eax, 256;
+    pop eax;
+    jnz label_32;
+    mov eax, edi;
+label_32:
+    
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+    }
+}
+__declspec(naked) void nseel_asm_max_end(void) {}
+
+
+
+
+
+// just generic functions left, yay
+
+
+
+
+__declspec(naked) void _asm_generic3parm(void)
+{
+  __asm {
+#ifdef TARGET_X64
+
+#ifdef AMD64ABI
+
+    mov r15, rsi;
+    mov rdx, rdi; // third parameter = parm
+    mov rdi, 0xFFFFFFFF; // first parameter= context
+
+    mov rsi, ecx; // second parameter = parm
+    mov rcx, rax; // fourth parameter = parm
+    mov rax, 0xffffffff; // call function
+    sub rsp, 128;
+    call rax;
+
+    mov rsi, r15;
+    add rsp, 128;
+
+#else
+    mov edx, ecx; // second parameter = parm
+    mov ecx, 0xFFFFFFFF; // first parameter= context
+    mov r8, rdi; // third parameter = parm
+    mov r9, rax; // fourth parameter = parm
+    mov edi, 0xffffffff; // call function
+    sub rsp, 128;
+    call edi;
+    add rsp, 128;
+#endif
+
+#else
+SAVE_STACK
+    mov edx, 0xFFFFFFFF;
+    push eax; // push parameter
+    push edi; // push parameter
+    push ecx; // push parameter
+    push edx; // push context pointer
+    mov edi, 0xffffffff;
+    call edi;
+    add esp, 16;
+RESTORE_STACK
+#endif
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+ }
+}
+__declspec(naked) void _asm_generic3parm_end(void) {}
+
+
+__declspec(naked) void _asm_generic3parm_retd(void)
+{
+  __asm {
+#ifdef TARGET_X64
+#ifdef AMD64ABI
+    mov r15, rsi;
+    mov rdx, rdi; // third parameter = parm
+    mov rdi, 0xFFFFFFFF; // first parameter= context
+    mov rsi, ecx; // second parameter = parm
+    mov rcx, rax; // fourth parameter = parm
+    mov rax, 0xffffffff; // call function
+    sub rsp, 128;
+    call rax;
+    add rsp, 128;
+    mov rsi, r15;
+    mov rax, r15;
+    movq [r15], xmm0;
+    add rsi, 8;
+#else
+    mov edx, ecx; // second parameter = parm
+    mov ecx, 0xFFFFFFFF; // first parameter= context
+    mov r8, rdi; // third parameter = parm
+    mov r9, rax; // fourth parameter = parm
+    mov edi, 0xffffffff; // call function
+    sub rsp, 128;
+    call edi;
+    add rsp, 128;
+    movq [rsi], xmm0;
+    mov rax, rsi;
+    add rsi, 8;
+#endif
+#else
+SAVE_STACK
+    mov edx, 0xFFFFFFFF;
+    push eax; // push parameter
+    push edi; // push parameter
+    push ecx; // push parameter
+    push edx; // push context pointer
+    mov edi, 0xffffffff;
+    call edi;
+    mov eax, esi;
+	  fstp EEL_ASM_TYPE [esi];
+   	add esi, EEL_F_SIZE;
+    add esp, 16;
+RESTORE_STACK
+#endif
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+ }
+}
+__declspec(naked) void _asm_generic3parm_retd_end(void) {}
+
+
+__declspec(naked) void _asm_generic2parm(void) // this prob neds to be fixed for ppc
+{
+  __asm {
+#ifdef TARGET_X64
+
+#ifdef AMD64ABI
+    mov r15, rsi;
+    mov esi, edi; // second parameter = parm
+    mov edi, 0xFFFFFFFF; // first parameter= context
+    mov rdx, rax; // third parameter = parm
+    mov rcx, 0xffffffff; // call function
+    sub rsp, 128;
+    call rcx;
+    mov rsi, r15;
+    add rsp, 128;
+#else
+    mov ecx, 0xFFFFFFFF; // first parameter= context
+    mov edx, edi; // second parameter = parm
+    mov r8, rax; // third parameter = parm
+    mov edi, 0xffffffff; // call function
+    sub rsp, 128;
+    call edi;
+    add rsp, 128;
+#endif
+#else
+SAVE_STACK
+    mov edx, 0xFFFFFFFF;
+    sub esp, 4; // keep stack aligned
+    push eax; // push parameter
+    push edi; // push parameter
+    push edx; // push context pointer
+    mov edi, 0xffffffff;
+    call edi;
+    add esp, 16;
+RESTORE_STACK
+#endif
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+ }
+}
+__declspec(naked) void _asm_generic2parm_end(void) {}
+
+
+__declspec(naked) void _asm_generic2parm_retd(void)
+{
+  __asm {
+#ifdef TARGET_X64
+#ifdef AMD64ABI
+    mov r15, rsi;
+    mov rsi, rdi; // second parameter = parm
+    mov rdi, 0xFFFFFFFF; // first parameter= context
+    mov rdx, rax; // third parameter = parm
+    mov rcx, 0xffffffff; // call function
+    sub rsp, 128;
+    call rcx;
+    mov rsi, r15;
+    add rsp, 128;
+    movq [r15], xmm0;
+    mov rax, r15;
+    add rsi, 8;
+#else
+    mov ecx, 0xFFFFFFFF; // first parameter= context
+    mov edx, edi; // second parameter = parm
+    mov r8, rax; // third parameter = parm
+    mov edi, 0xffffffff; // call function
+    sub rsp, 128;
+    call edi;
+    add rsp, 128;
+    movq [rsi], xmm0;
+    mov rax, rsi;
+    add rsi, 8;
+#endif
+#else
+SAVE_STACK
+    mov edx, 0xFFFFFFFF;
+    push eax; // push parameter
+    push edi; // push parameter
+    push ecx; // push parameter
+    push edx; // push context pointer
+    mov edi, 0xffffffff;
+    call edi;
+    mov eax, esi;
+	  fstp EEL_ASM_TYPE [esi];
+   	add esi, EEL_F_SIZE;
+    add esp, 16;
+RESTORE_STACK
+#endif
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+ }
+}
+__declspec(naked) void _asm_generic2parm_retd_end(void) {}
+
+
+
+
+
+__declspec(naked) void _asm_generic1parm(void) // this prob neds to be fixed for ppc
+{
+  __asm {
+#ifdef TARGET_X64
+#ifdef AMD64ABI
+    mov rdi, 0xFFFFFFFF; // first parameter= context
+    mov r15, rsi;
+    mov rsi, eax; // second parameter = parm
+    sub rsp, 128;
+    mov rcx, 0xffffffff; // call function
+    call rcx;
+    mov rsi, r15;
+    add rsp, 128;
+#else
+    mov ecx, 0xFFFFFFFF; // first parameter= context
+    mov edx, eax; // second parameter = parm
+    mov edi, 0xffffffff; // call function
+    sub rsp, 128;
+    call edi;
+    add rsp, 128;
+#endif
+#else
+SAVE_STACK
+    mov edx, 0xFFFFFFFF;
+    sub esp, 8; // keep stack aligned
+    push eax; // push parameter
+    push edx; // push context pointer
+    mov edi, 0xffffffff;
+    call edi;
+    add esp, 16;
+RESTORE_STACK
+#endif
+
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+ }
+}
+__declspec(naked) void _asm_generic1parm_end(void) {}
+
+
+__declspec(naked) void _asm_generic1parm_retd(void) // 1 parameter returning double
+{
+  __asm {
+#ifdef TARGET_X64
+#ifdef AMD64ABI
+    mov r15, rsi;
+    mov rdi, 0xFFFFFFFF; // first parameter= context
+    mov rsi, rax; // second parameter = parm
+    mov rcx, 0xffffffff; // call function
+    sub rsp, 128;
+    call rcx;
+    mov rsi, r15;
+    add rsp, 128;
+    movq [r15], xmm0;
+    mov rax, r15;
+    add rsi, 8;
+#else
+    mov ecx, 0xFFFFFFFF; // first parameter= context
+    mov edx, eax; // second parameter = parm
+    mov edi, 0xffffffff; // call function
+    sub rsp, 128;
+    call edi;
+    add rsp, 128;
+    movq [rsi], xmm0;
+    mov rax, rsi;
+    add rsi, 8;
+#endif
+#else
+SAVE_STACK
+    mov edx, 0xFFFFFFFF;
+    sub esp, 8; // keep stack aligned
+    push eax; // push parameter
+    push edx; // push context pointer
+    mov edi, 0xffffffff;
+    call edi;
+	  mov eax, esi;
+	  fstp EEL_ASM_TYPE [esi];
+	  add esi, EEL_F_SIZE;
+    add esp, 16;
+RESTORE_STACK
+#endif
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+ }
+}
+__declspec(naked) void _asm_generic1parm_retd_end(void) {}
+
+
+
+
+
+// this gets its own stub because it's pretty crucial for performance :/
+
+__declspec(naked) void _asm_megabuf(void)
+{
+  __asm {
+SAVE_STACK
+
+#ifdef TARGET_X64
+
+
+#ifdef AMD64ABI
+
+    mov r15, rsi;
+    mov rdi, 0xFFFFFFFF; // first parameter = context pointer
+    fld EEL_ASM_TYPE [eax];
+    mov rdx, 0xFFFFFFFF;
+    fadd EEL_ASM_TYPE [rdx];
+    fistp dword ptr [r15];
+    xor rsi, rsi;
+    mov esi, dword ptr [r15]; // r15 = esi (from above)
+    mov edx, 0xffffffff;
+    sub rsp, 128;
+    call edx;
+    mov rsi, r15;
+    add rsp, 128;
+    and rax, rax;
+    jnz label_33;
+    mov rax, r15;
+    mov qword ptr [esi], 0;
+    add rsi, EEL_F_SIZE;
+label_33:
+    
+
+#else
+    mov ecx, 0xFFFFFFFF; // first parameter = context pointer
+    fld EEL_ASM_TYPE [eax];
+	mov edx, 0xFFFFFFFF;
+    fadd EEL_ASM_TYPE [rdx];
+    fistp dword ptr [esi];
+    xor rdx, rdx;
+    mov edx, dword ptr [esi];
+    mov edi, 0xffffffff;
+	sub rsp, 128;
+    call edi;
+	add rsp, 128;
+    and rax, rax;
+    jnz label_34;
+    mov rax, rsi;
+    mov qword ptr [esi], 0;
+    add esi, EEL_F_SIZE;
+label_34:
+    
+#endif
+
+
+#else
+    mov edx, 0xFFFFFFFF;
+    fld EEL_ASM_TYPE [eax];
+#if EEL_F_SIZE == 8
+_emit 0xDC; // fadd qword ptr [0xffffffff]
+_emit 0x05;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#else
+_emit 0xD8; // fadd dword ptr [0xffffffff]
+_emit 0x05;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+_emit 0xFF;
+#endif
+    fistp dword ptr [esi];
+    sub esp, 8; // keep stack aligned
+    push dword ptr [esi]; // parameter
+    push edx; // push context pointer
+    mov edi, 0xffffffff;
+    call edi;
+    add esp, 16;
+    and eax, eax;
+    jnz label_35;
+    mov eax, esi;
+    mov dword ptr [esi], 0;
+#if EEL_F_SIZE == 8
+    mov dword ptr [esi+4], 0;
+#endif
+    add esi, EEL_F_SIZE;
+label_35:
+    
+
+
+#endif
+
+RESTORE_STACK
+
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+ }
+}
+
+__declspec(naked) void _asm_megabuf_end(void) {}
+
+
+#ifdef TARGET_X64
+__declspec(naked) void win64_callcode()
+{
+	__asm {
+#ifdef AMD64ABI
+		mov eax, edi;
+#else
+		mov eax, ecx;
+#endif
+
+		push rbx;
+		push rbp;
+#ifndef AMD64ABI
+		push rdi;
+		push rsi;
+		push r12;
+		push r13;
+#endif
+		push r14; // on AMD64ABI, we'll use r14/r15 to save edi/esi
+		push r15;
+		call eax;
+		pop r15;
+		pop r14;
+#ifndef AMD64ABI
+		pop r13;
+		pop r12;
+		pop rsi;
+		pop rdi;
+		fclex;
+#endif
+		pop rbp;
+		pop rbx;
+		ret;
+_emit 0x89;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+_emit 0x90;
+	}
+}
+
+#endif
diff --git a/Src/Plugins/Visualization/vis_milk2/ns-eel2/ns-eel-addfuncs.h b/Src/Plugins/Visualization/vis_milk2/ns-eel2/ns-eel-addfuncs.h
new file mode 100644
index 00000000..e653e0a1
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_milk2/ns-eel2/ns-eel-addfuncs.h
@@ -0,0 +1,74 @@
+/*
+  Nullsoft Expression Evaluator Library (NS-EEL)
+  Copyright (C) 1999-2003 Nullsoft, Inc.
+  
+  ns-eel-addfuncs.h: defines macros useful for adding functions to the compiler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __NS_EEL_ADDFUNCS_H__
+#define __NS_EEL_ADDFUNCS_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _compileContext;
+typedef void (*NSEEL_PPPROC)(void *data, int data_size, struct _compileContext *userfunc_data);
+
+void NSEEL_PProc_RAM(void *data, int data_size, struct _compileContext *ctx);
+void NSEEL_PProc_THIS(void *data, int data_size, struct _compileContext *ctx);
+
+
+void _asm_generic3parm(void); // 3 double * parms, returning double *
+void _asm_generic3parm_end(void);
+void _asm_generic3parm_retd(void); // 3 double * parms, returning double
+void _asm_generic3parm_retd_end(void);
+void _asm_generic2parm(void); // 2 double * parms, returning double *
+void _asm_generic2parm_end(void);
+void _asm_generic2parm_retd(void); // 2 double * parms, returning double
+void _asm_generic2parm_retd_end(void);
+void _asm_generic1parm(void); // 1 double * parms, returning double *
+void _asm_generic1parm_end(void);
+void _asm_generic1parm_retd(void); // 1 double * parms, returning double 
+void _asm_generic1parm_retd_end(void);
+
+void _asm_megabuf(void);
+void _asm_megabuf_end(void);
+
+
+
+#if EEL_F_SIZE == 4
+#define EEL_F_SSTR "4"
+#define EEL_F_SUFFIX "s"
+#else
+#define EEL_F_SSTR "8"
+#define EEL_F_SUFFIX "l"
+#endif
+
+#ifdef _MSC_VER
+#define NSEEL_CGEN_CALL __cdecl
+#else
+#define NSEEL_CGEN_CALL 
+#endif
+
+#ifdef __cplusplus
+};
+
+#endif
+#endif//__NS_EEL_ADDFUNCS_H__
diff --git a/Src/Plugins/Visualization/vis_milk2/ns-eel2/ns-eel-int.h b/Src/Plugins/Visualization/vis_milk2/ns-eel2/ns-eel-int.h
new file mode 100644
index 00000000..3718604a
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_milk2/ns-eel2/ns-eel-int.h
@@ -0,0 +1,227 @@
+/*
+  Nullsoft Expression Evaluator Library (NS-EEL)
+  Copyright (C) 1999-2003 Nullsoft, Inc.
+  
+  ns-eel-int.h: internal code definition header.
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __NS_EELINT_H__
+#define __NS_EELINT_H__
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include "../wdltypes.h"
+#endif
+
+#include "ns-eel.h"
+#include "ns-eel-addfuncs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define FN_ASSIGN   0
+#define FN_MULTIPLY 1
+#define FN_DIVIDE   2
+#define FN_MODULO   3
+#define FN_ADD      4
+#define FN_SUB      5
+#define FN_AND      6
+#define FN_OR       7
+#define FN_UMINUS   8
+#define FN_UPLUS    9
+
+#define MATH_SIMPLE 0
+#define MATH_FN     1
+
+#define YYSTYPE INT_PTR
+
+#define NSEEL_CLOSEFACTOR 0.00001
+
+typedef struct
+{
+	int srcByteCount;
+	int destByteCount;
+} lineRecItem;
+
+typedef struct _compileContext
+{
+  EEL_F **varTable_Values;
+  char   **varTable_Names;
+  int varTable_numBlocks;
+
+  int errVar;
+  int colCount;
+  INT_PTR result;
+  char last_error_string[256];
+  YYSTYPE yylval;
+  int	yychar;			/*  the lookahead symbol		*/
+  int yynerrs;			/*  number of parse errors so far       */
+  char yytext[256];
+  char lastVar[256];
+
+  char    *llsave[16];             /* Look ahead buffer            */
+  char    llbuf[100];             /* work buffer                          */
+  char    *llp1;//   = &llbuf[0];    /* pointer to next avail. in token      */
+  char    *llp2;//   = &llbuf[0];    /* pointer to end of lookahead          */
+  char    *llend;//  = &llbuf[0];    /* pointer to end of token              */
+  char    *llebuf;// = &llbuf[sizeof llbuf];
+  int     lleof;
+  int     yyline;//  = 0;
+
+  void *tmpblocks_head,*blocks_head;
+  int computTableTop; // make it abort on potential overflow =)
+  int l_stats[4]; // source bytes, static code bytes, call code bytes, data bytes
+
+  lineRecItem *compileLineRecs;
+  int compileLineRecs_size;
+  int compileLineRecs_alloc;
+
+  void *ram_blocks; // this needs to be immediately followed by
+  int ram_needfree;
+
+  void *gram_blocks;
+
+  void *caller_this;
+}
+compileContext;
+
+#define NSEEL_VARS_PER_BLOCK 64
+
+typedef struct {
+      const char *name;
+      void *afunc;
+      void *func_e;
+      int nParams;
+      void *replptrs[4];
+      NSEEL_PPPROC pProc;
+} functionType;
+
+
+extern functionType *nseel_getFunctionFromTable(int idx);
+
+INT_PTR nseel_createCompiledValue(compileContext *ctx, EEL_F value, EEL_F *addrValue);
+INT_PTR nseel_createCompiledFunction1(compileContext *ctx, int fntype, INT_PTR fn, INT_PTR code);
+INT_PTR nseel_createCompiledFunction2(compileContext *ctx, int fntype, INT_PTR fn, INT_PTR code1, INT_PTR code2);
+INT_PTR nseel_createCompiledFunction3(compileContext *ctx, int fntype, INT_PTR fn, INT_PTR code1, INT_PTR code2, INT_PTR code3);
+
+extern EEL_F nseel_globalregs[100];
+
+void nseel_resetVars(compileContext *ctx);
+EEL_F *nseel_getVarPtr(compileContext *ctx, char *varName);
+EEL_F *nseel_registerVar(compileContext *ctx, char *varName);
+
+INT_PTR *EEL_GLUE_set_immediate(void *_p, void *newv);
+
+// other shat
+
+
+
+INT_PTR nseel_setVar(compileContext *ctx, INT_PTR varNum);
+INT_PTR nseel_getVar(compileContext *ctx, INT_PTR varNum);
+void *nseel_compileExpression(compileContext *ctx, char *txt);
+
+#define	VALUE	258
+#define	IDENTIFIER	259
+#define	FUNCTION1	260
+#define	FUNCTION2	261
+#define	FUNCTION3	262
+#define	UMINUS	263
+#define	UPLUS	264
+
+INT_PTR nseel_translate(compileContext *ctx, int type);
+void nseel_count(compileContext *ctx);
+void nseel_setLastVar(compileContext *ctx);
+INT_PTR nseel_lookup(compileContext *ctx, int *typeOfObject);
+int nseel_yyerror(compileContext *ctx);
+int nseel_yylex(compileContext *ctx, char **exp);
+int nseel_yyparse(compileContext *ctx, char *exp);
+void nseel_llinit(compileContext *ctx);
+int nseel_gettoken(compileContext *ctx, char *lltb, int lltbsiz);
+
+struct  lextab {
+        int     llendst;                /* Last state number            */
+        char    *lldefault;             /* Default state table          */
+        char    *llnext;                /* Next state table             */
+        char    *llcheck;               /* Check table                  */
+        int     *llbase;                /* Base table                   */
+        int     llnxtmax;               /* Last in next table           */
+        int     (*llmove)();            /* Move between states          */
+        char     *llfinal;               /* Final state descriptions     */
+        int     (*llactr)();            /* Action routine               */
+        int     *lllook;                /* Look ahead vector if != NULL */
+        char    *llign;                 /* Ignore char vec if != NULL   */
+        char    *llbrk;                 /* Break char vec if != NULL    */
+        char    *llill;                 /* Illegal char vec if != NULL  */
+};
+extern struct lextab nseel_lextab;
+
+EEL_F * NSEEL_CGEN_CALL __NSEEL_RAMAlloc(EEL_F ***blocks, int w);
+EEL_F * NSEEL_CGEN_CALL __NSEEL_RAMAllocGMEM(EEL_F ***blocks, int w);
+EEL_F * NSEEL_CGEN_CALL __NSEEL_RAM_MemSet(EEL_F ***blocks,EEL_F *dest, EEL_F *v, EEL_F *lenptr);
+EEL_F * NSEEL_CGEN_CALL __NSEEL_RAM_MemFree(EEL_F ***blocks, EEL_F *which);
+EEL_F * NSEEL_CGEN_CALL __NSEEL_RAM_MemCpy(EEL_F ***blocks,EEL_F *dest, EEL_F *src, EEL_F *lenptr);
+
+
+
+#ifndef max
+#define max(x,y) ((x)<(y)?(y):(x))
+#define min(x,y) ((x)<(y)?(x):(y))
+#endif
+
+
+
+#ifdef __ppc__
+
+  #define EEL_F2int(x) ((int)(x))
+
+#elif defined (_WIN64)
+
+  // todo: AMD64 version?
+  #define EEL_F2int(x) ((int)(x))
+
+#elif defined(_MSC_VER)
+
+static __inline int EEL_F2int(EEL_F d)
+{
+  int tmp;
+  __asm {
+    fld d
+    fistp tmp
+  }
+  return tmp;
+}
+
+#else
+
+static inline int EEL_F2int(EEL_F d)
+{
+	  int tmp;
+    __asm__ __volatile__ ("fistpl %0" : "=m" (tmp) : "t" (d) : "st") ;
+    return tmp;
+}
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif//__NS_EELINT_H__
diff --git a/Src/Plugins/Visualization/vis_milk2/ns-eel2/ns-eel.h b/Src/Plugins/Visualization/vis_milk2/ns-eel2/ns-eel.h
new file mode 100644
index 00000000..cb561377
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_milk2/ns-eel2/ns-eel.h
@@ -0,0 +1,155 @@
+/*
+  Nullsoft Expression Evaluator Library (NS-EEL)
+  Copyright (C) 1999-2003 Nullsoft, Inc.
+  
+  ns-eel.h: main application interface header
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#ifndef __NS_EEL_H__
+#define __NS_EEL_H__
+
+// put standard includes here
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef _MSC_VER
+#define strcasecmp stricmp
+#define strncasecmp _strnicmp
+#endif
+
+#ifndef EEL_F_SIZE
+#define EEL_F_SIZE 8
+#endif
+
+#if EEL_F_SIZE == 4
+typedef float EEL_F;
+#else
+typedef double EEL_F;
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// host should implement these (can be empty stub functions if no VM will execute code in multiple threads at once)
+
+  // implement if you will be running the code in same VM from multiple threads, 
+  // or VMs that have the same GRAM pointer from different threads, or multiple
+  // VMs that have a NULL GRAM pointer from multiple threads.
+  // if you give each VM it's own unique GRAM and only run each VM in one thread, then you can leave it blank.
+
+  // or if you're daring....
+
+void NSEEL_HOSTSTUB_EnterMutex();
+void NSEEL_HOSTSTUB_LeaveMutex();
+
+
+int NSEEL_init(); // returns 0 on success. clears any added functions as well
+
+#define NSEEL_addfunction(name,nparms,code,len) NSEEL_addfunctionex((name),(nparms),(code),(len),0,0)
+#define NSEEL_addfunctionex(name,nparms,code,len,pproc,fptr) NSEEL_addfunctionex2((name),(nparms),(code),(len),(pproc),(fptr),0)
+void NSEEL_addfunctionex2(const char *name, int nparms, char *code_startaddr, int code_len, void *pproc, void *fptr, void *fptr2);
+
+void NSEEL_quit();
+
+int *NSEEL_getstats(); // returns a pointer to 5 ints... source bytes, static code bytes, call code bytes, data bytes, number of code handles
+EEL_F *NSEEL_getglobalregs();
+
+typedef void *NSEEL_VMCTX;
+typedef void *NSEEL_CODEHANDLE;
+
+NSEEL_VMCTX NSEEL_VM_alloc(); // return a handle
+void NSEEL_VM_free(NSEEL_VMCTX ctx); // free when done with a VM and ALL of its code have been freed, as well
+
+void NSEEL_VM_enumallvars(NSEEL_VMCTX ctx, int (*func)(const char *name, EEL_F *val, void *ctx), void *userctx); // return false from func to stop
+void NSEEL_VM_resetvars(NSEEL_VMCTX ctx); // clears all vars to 0.0.
+
+EEL_F *NSEEL_VM_regvar(NSEEL_VMCTX ctx, const char *name); // register a variable (before compilation)
+
+void NSEEL_VM_freeRAM(NSEEL_VMCTX ctx); // clears and frees all (VM) RAM used
+void NSEEL_VM_freeRAMIfCodeRequested(NSEEL_VMCTX); // call after code to free the script-requested memory
+int NSEEL_VM_wantfreeRAM(NSEEL_VMCTX ctx); // want NSEEL_VM_freeRAMIfCodeRequested?
+
+// if you set this, it uses a local GMEM context. 
+// Must be set before compilation. 
+// void *p=NULL; 
+// NSEEL_VM_SetGRAM(ctx,&p);
+// .. do stuff
+// NSEEL_VM_FreeGRAM(&p);
+void NSEEL_VM_SetGRAM(NSEEL_VMCTX ctx, void **gram); 
+void NSEEL_VM_FreeGRAM(void **ufd); // frees a gmem context.
+void NSEEL_VM_SetCustomFuncThis(NSEEL_VMCTX ctx, void *thisptr);
+
+
+  // note that you shouldnt pass a C string directly, since it may need to 
+  // fudge with the string during the compilation (it will always restore it to the 
+  // original value though).
+#ifdef __cplusplus
+NSEEL_CODEHANDLE NSEEL_code_compile(NSEEL_VMCTX ctx, char *code, int lineoffs=0);
+#else
+NSEEL_CODEHANDLE NSEEL_code_compile(NSEEL_VMCTX ctx, char *code, int lineoffs);
+#endif
+
+char *NSEEL_code_getcodeerror(NSEEL_VMCTX ctx);
+void NSEEL_code_execute(NSEEL_CODEHANDLE code);
+void NSEEL_code_free(NSEEL_CODEHANDLE code);
+int *NSEEL_code_getstats(NSEEL_CODEHANDLE code); // 4 ints...source bytes, static code bytes, call code bytes, data bytes
+  
+
+// global memory control/view
+extern unsigned int NSEEL_RAM_limitmem; // if nonzero, memory limit for user data, in bytes
+extern unsigned int NSEEL_RAM_memused;
+extern int NSEEL_RAM_memused_errors;
+
+
+
+// configuration:
+
+#define NSEEL_MAX_VARIABLE_NAMELEN 16
+// define this to override the max variable length (default is 16 bytes)
+
+//#define NSEEL_MAX_TEMPSPACE_ENTRIES 2048
+// define this to override the maximum working space in 8 byte units.
+// 2048 is the default, and is way more than enough for most applications
+// but in theory you might be able to come up with an expression big enough? maybe?
+
+
+// maximum loop length
+#define NSEEL_LOOPFUNC_SUPPORT_MAXLEN 1048576 // scary, we can do a million entries. probably will never want to, though.
+#define NSEEL_LOOPFUNC_SUPPORT_MAXLEN_STR "1048576"
+
+
+
+// when a VM ctx doesn't have a GRAM context set, make the global one this big
+#define NSEEL_SHARED_GRAM_SIZE (1<<20)
+
+// 128*65536 = ~8million entries. (64MB RAM used)
+#define NSEEL_RAM_BLOCKS 128
+#define NSEEL_RAM_ITEMSPERBLOCK 65536
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif//__NS_EEL_H__
diff --git a/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-caltab.c b/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-caltab.c
new file mode 100644
index 00000000..1d8a6d32
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-caltab.c
@@ -0,0 +1,553 @@
+/*
+  Expression Evaluator Library (NS-EEL) v2
+  Copyright (C) 2004-2008 Cockos Incorporated
+  Copyright (C) 1999-2003 Nullsoft, Inc.
+  
+  nseel-caltab.c
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "ns-eel-int.h"
+
+#define	VALUE	258
+#define	IDENTIFIER	259
+#define	FUNCTION1	260
+#define	FUNCTION2	261
+#define	FUNCTION3	262
+#define	UMINUS	263
+#define	UPLUS	264
+
+#define YYERROR(x) nseel_yyerror(ctx)
+       
+#define	YYFINAL		51
+#define	YYFLAG		-32768
+#define	YYNTBASE	21
+
+#define YYTRANSLATE(x) ((unsigned)(x) <= 264 ? yytranslate[x] : 26)
+
+static const char yytranslate[] = {     0,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,    14,     9,     2,    18,
+    19,    12,    10,    20,    11,     2,    13,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+    17,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     8,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
+     6,     7,    15,    16
+};
+
+
+static const short yyr1[] = {     0,
+    21,    21,    22,    23,    23,    23,    24,    24,    24,    24,
+    24,    24,    24,    24,    24,    24,    24,    25,    25,    25
+};
+
+static const short yyr2[] = {     0,
+     1,     3,     1,     1,     1,     3,     1,     3,     3,     3,
+     3,     3,     3,     3,     2,     2,     1,     4,     6,     8
+};
+
+static const short yydefact[] = {     0,
+     3,     4,     0,     0,     0,     0,     0,     0,     5,     7,
+     1,    17,     0,     0,     0,     0,     4,    16,    15,     0,
+     0,     0,     0,     0,     0,     0,     0,     2,     0,     0,
+     0,     6,    14,    13,    11,    12,     8,     9,    10,    18,
+     0,     0,     0,     0,    19,     0,     0,    20,     0,     0,
+     0
+};
+
+static const short yydefgoto[] = {    49,
+     9,    10,    11,    12
+};
+
+static const short yypact[] = {    19,
+-32768,   -11,    -7,    -5,    -4,    38,    38,    38,-32768,-32768,
+   136,-32768,    38,    38,    38,    38,-32768,-32768,-32768,    88,
+    38,    38,    38,    38,    38,    38,    38,   136,   100,    49,
+    62,-32768,    41,    54,    -9,    -9,-32768,-32768,-32768,-32768,
+    38,    38,   112,    75,-32768,    38,   124,-32768,    12,    27,
+-32768
+};
+
+static const short yypgoto[] = {-32768,
+-32768,-32768,    -6,-32768
+};
+
+
+#define	YYLAST		150
+
+
+static const short yytable[] = {    18,
+    19,    20,    25,    26,    27,    13,    28,    29,    30,    31,
+    14,    50,    15,    16,    33,    34,    35,    36,    37,    38,
+    39,     1,     2,     3,     4,     5,    51,     0,     6,     7,
+     0,     0,     0,     0,    43,    44,     8,     0,     0,    47,
+     1,    17,     3,     4,     5,     0,     0,     6,     7,    22,
+    23,    24,    25,    26,    27,     8,    21,    22,    23,    24,
+    25,    26,    27,    23,    24,    25,    26,    27,    41,    21,
+    22,    23,    24,    25,    26,    27,     0,     0,     0,     0,
+     0,    42,    21,    22,    23,    24,    25,    26,    27,     0,
+     0,     0,     0,     0,    46,    21,    22,    23,    24,    25,
+    26,    27,     0,     0,     0,     0,    32,    21,    22,    23,
+    24,    25,    26,    27,     0,     0,     0,     0,    40,    21,
+    22,    23,    24,    25,    26,    27,     0,     0,     0,     0,
+    45,    21,    22,    23,    24,    25,    26,    27,     0,     0,
+     0,     0,    48,    21,    22,    23,    24,    25,    26,    27
+};
+
+static const short yycheck[] = {     6,
+     7,     8,    12,    13,    14,    17,    13,    14,    15,    16,
+    18,     0,    18,    18,    21,    22,    23,    24,    25,    26,
+    27,     3,     4,     5,     6,     7,     0,    -1,    10,    11,
+    -1,    -1,    -1,    -1,    41,    42,    18,    -1,    -1,    46,
+     3,     4,     5,     6,     7,    -1,    -1,    10,    11,     9,
+    10,    11,    12,    13,    14,    18,     8,     9,    10,    11,
+    12,    13,    14,    10,    11,    12,    13,    14,    20,     8,
+     9,    10,    11,    12,    13,    14,    -1,    -1,    -1,    -1,
+    -1,    20,     8,     9,    10,    11,    12,    13,    14,    -1,
+    -1,    -1,    -1,    -1,    20,     8,     9,    10,    11,    12,
+    13,    14,    -1,    -1,    -1,    -1,    19,     8,     9,    10,
+    11,    12,    13,    14,    -1,    -1,    -1,    -1,    19,     8,
+     9,    10,    11,    12,    13,    14,    -1,    -1,    -1,    -1,
+    19,     8,     9,    10,    11,    12,    13,    14,    -1,    -1,
+    -1,    -1,    19,     8,     9,    10,    11,    12,    13,    14
+};
+
+#define yyerrok		(yyerrstatus = 0)
+#define yyclearin	(ctx->yychar = YYEMPTY)
+#define YYEMPTY		-2
+#define YYEOF		0
+#define YYACCEPT	return(0)
+#define YYABORT 	return(1)
+
+#define YYTERROR	1
+#define YYERRCODE	256
+
+#define YYLEX		nseel_yylex(ctx,&exp)
+
+/* If nonreentrant, generate the variables here */
+
+/*  YYINITDEPTH indicates the initial size of the parser's stacks	*/
+
+#define YYINITDEPTH 5000
+#define YYMAXDEPTH 5000
+
+/* This is the most reliable way to avoid incompatibilities
+   in available built-in functions on various systems.  */
+#define __yy_bcopy(from,to,count) memcpy(to,from,(count)>0?(count):0)
+
+//#ln 131 "bison.simple"
+int nseel_yyparse(compileContext *ctx, char *exp)
+{
+  register int yystate;
+  register int yyn;
+  register short *yyssp;
+  register YYSTYPE *yyvsp;
+  int yyerrstatus;	/*  number of tokens to shift before error messages enabled */
+  int yychar1;		/*  lookahead token as an internal (translated) token number */
+
+  short	yyssa[YYINITDEPTH];	/*  the state stack			*/
+  YYSTYPE yyvsa[YYINITDEPTH];	/*  the semantic value stack		*/
+
+  short *yyss = yyssa;		/*  refer to the stacks thru separate pointers */
+  YYSTYPE *yyvs = yyvsa;	/*  to allow yyoverflow to reallocate them elsewhere */
+
+  int yystacksize = YYINITDEPTH;
+
+  YYSTYPE yyval;		/*  the variable used to return		*/
+				/*  semantic values from the action	*/
+				/*  routines				*/
+
+  int yylen;
+
+  ctx->yylval = 0;
+  yystate = 0;
+  yyerrstatus = 0;
+  ctx->yynerrs = 0;
+  ctx->yychar = YYEMPTY;		/* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.  */
+
+  yyssp = yyss - 1;
+  yyvsp = yyvs;
+
+/* Push a new state, which is found in  yystate  .  */
+/* In all cases, when you get here, the value and location stacks
+   have just been pushed. so pushing a state here evens the stacks.  */
+yynewstate:
+
+  *++yyssp = yystate;
+
+  if (yyssp >= yyss + yystacksize - 1)
+    {
+      /* Give user a chance to reallocate the stack */
+      /* Use copies of these so that the &'s don't force the real ones into memory. */
+//      YYSTYPE *yyvs1 = yyvs;
+  //    short *yyss1 = yyss;
+
+      /* Get the current used size of the three stacks, in elements.  */
+      int size = yyssp - yyss + 1;
+
+      if (yystacksize >= YYMAXDEPTH)
+    	{
+	      YYERROR("internal error: parser stack overflow");
+	      return 2;
+	    }
+
+      yyssp = yyss + size - 1;
+      yyvsp = yyvs + size - 1;
+
+
+      if (yyssp >= yyss + yystacksize - 1) YYABORT;
+    }
+
+
+// yybackup:
+
+/* Do appropriate processing given the current state.  */
+/* Read a lookahead token if we need one and don't already have one.  */
+/* yyresume: */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* yychar is either YYEMPTY or YYEOF
+     or a valid token in external form.  */
+
+  if (ctx->yychar == YYEMPTY)
+    {
+//	yyStackSize = yyssp - (yyss - 1);
+	ctx->yychar = YYLEX;
+    }
+
+  /* Convert token to internal form (in yychar1) for indexing tables with */
+
+  if (ctx->yychar <= 0)		/* This means end of input. */
+    {
+      yychar1 = 0;
+      ctx->yychar = YYEOF;		/* Don't call YYLEX any more */
+
+    }
+  else
+    {
+      yychar1 = YYTRANSLATE(ctx->yychar);
+
+    }
+
+  yyn += yychar1;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+    goto yydefault;
+
+  yyn = yytable[yyn];
+
+  /* yyn is what to do for this token type in this state.
+     Negative => reduce, -yyn is rule number.
+     Positive => shift, yyn is new state.
+       New state is final state => don't bother to shift,
+       just return success.
+     0, or most negative number => error.  */
+
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+	goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrlab;
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  /* Shift the lookahead token.  */
+
+
+  /* Discard the token being shifted unless it is eof.  */
+  if (ctx->yychar != YYEOF)
+    ctx->yychar = YYEMPTY;
+
+  *++yyvsp = ctx->yylval;
+
+  /* count tokens shifted since error; after three, turn off error status.  */
+  if (yyerrstatus) yyerrstatus--;
+
+  yystate = yyn;
+  goto yynewstate;
+
+/* Do the default action for the current state.  */
+yydefault:
+
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+
+/* Do a reduction.  yyn is the number of a rule to reduce with.  */
+yyreduce:
+  yylen = yyr2[yyn];
+  yyval = yyvsp[1-yylen]; /* implement default value of the action */
+
+
+  switch (yyn) {
+
+case 1:
+//#ln 32 "cal.y"
+{       yyval = yyvsp[0]; ctx->result = yyvsp[0];     ;
+    break;}
+case 2:
+//#ln 34 "cal.y"
+{                                {
+                                 YYSTYPE i = nseel_setVar(ctx,yyvsp[-2]);
+                                 YYSTYPE v=nseel_getVar(ctx,i);
+
+                                 yyval = nseel_createCompiledFunction2(ctx,MATH_SIMPLE, FN_ASSIGN, v, yyvsp[0]);
+                                 ctx->result = yyval;
+                                 }
+                       ;
+    break;}
+case 3:
+//#ln 50 "cal.y"
+{ yyval = yyvsp[0] ;
+    break;}
+case 4:
+//#ln 55 "cal.y"
+{       yyval = nseel_getVar(ctx,yyvsp[0]);;
+    break;}
+case 5:
+//#ln 57 "cal.y"
+{       yyval = yyvsp[0];;
+    break;}
+case 6:
+//#ln 59 "cal.y"
+{       yyval = yyvsp[-1];;
+    break;}
+case 7:
+//#ln 64 "cal.y"
+{ yyval = yyvsp[0];              ;
+    break;}
+case 8:
+//#ln 66 "cal.y"
+{                                 yyval = nseel_createCompiledFunction2(ctx,MATH_SIMPLE, FN_MULTIPLY, yyvsp[-2], yyvsp[0]);
+    break;}
+case 9:
+//#ln 72 "cal.y"
+{                                 yyval = nseel_createCompiledFunction2(ctx,MATH_SIMPLE, FN_DIVIDE, yyvsp[-2], yyvsp[0]);
+    break;}
+case 10:
+//#ln 78 "cal.y"
+{                                  yyval = nseel_createCompiledFunction2(ctx,MATH_SIMPLE, FN_MODULO, yyvsp[-2], yyvsp[0]);
+    break;}
+case 11:
+//#ln 84 "cal.y"
+{                                 yyval = nseel_createCompiledFunction2(ctx,MATH_SIMPLE, FN_ADD, yyvsp[-2], yyvsp[0]);
+    break;}
+case 12:
+//#ln 90 "cal.y"
+{                                 yyval = nseel_createCompiledFunction2(ctx,MATH_SIMPLE, FN_SUB, yyvsp[-2], yyvsp[0]);
+    break;}
+case 13:
+//#ln 96 "cal.y"
+{                                  yyval = nseel_createCompiledFunction2(ctx,MATH_SIMPLE, FN_AND, yyvsp[-2], yyvsp[0]);
+    break;}
+case 14:
+//#ln 102 "cal.y"
+{                                  yyval = nseel_createCompiledFunction2(ctx,MATH_SIMPLE, FN_OR, yyvsp[-2], yyvsp[0]);
+    break;}
+case 15:
+//#ln 108 "cal.y"
+{                                  yyval = nseel_createCompiledFunction1(ctx,MATH_SIMPLE, FN_UMINUS, yyvsp[0]);
+    break;}
+case 16:
+//#ln 114 "cal.y"
+{                                 yyval = nseel_createCompiledFunction1(ctx,MATH_SIMPLE, FN_UPLUS, yyvsp[0]);
+    break;}
+case 17:
+//#ln 120 "cal.y"
+{       yyval = yyvsp[0];     
+    break;}
+case 18:
+//#ln 125 "cal.y"
+{                                  yyval = nseel_createCompiledFunction1(ctx,MATH_FN, yyvsp[-3], yyvsp[-1]);
+    break;}
+case 19:
+//#ln 131 "cal.y"
+{                                 yyval = nseel_createCompiledFunction2(ctx,MATH_FN, yyvsp[-5], yyvsp[-3], yyvsp[-1]);
+    break;}
+case 20:
+//#ln 137 "cal.y"
+{                                 yyval = nseel_createCompiledFunction3(ctx,MATH_FN, yyvsp[-7], yyvsp[-5], yyvsp[-3], yyvsp[-1]);
+    break;}
+}
+   /* the action file gets copied in in place of this dollarsign */
+//#ln 362 "bison.simple"
+
+  yyvsp -= yylen;
+  yyssp -= yylen;
+
+  *++yyvsp = yyval;
+
+
+  /* Now "shift" the result of the reduction.
+     Determine what state that goes to,
+     based on the state we popped back to
+     and the rule number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTBASE];
+
+  goto yynewstate;
+
+yyerrlab:   /* here on detecting error */
+
+  if (! yyerrstatus)
+    /* If not already recovering from an error, report this error.  */
+    {
+      ++ctx->yynerrs;
+
+#ifdef YYERROR_VERBOSE
+      yyn = yypact[yystate];
+
+      if (yyn > YYFLAG && yyn < YYLAST)
+	{
+	  int size = 0;
+	  char *msg;
+	  int x, count;
+
+	  count = 0;
+	  for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
+	    if (yycheck[x + yyn] == x)
+	      size += strlen(yytname[x]) + 15, count++;
+#error this should not compile
+      msg = (char *) xmalloc(size + 15);
+	  strcpy(msg, "syntax error");
+
+	  if (count < 5)
+	    {
+	      count = 0;
+	      for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
+		if (yycheck[x + yyn] == x)
+		  {
+		    strcat(msg, count == 0 ? ", expecting `" : " or `");
+		    strcat(msg, yytname[x]);
+		    strcat(msg, "'");
+		    count++;
+		  }
+	    }
+	  YYERROR(msg);
+	  free(msg);
+	}
+      else
+#endif /* YYERROR_VERBOSE */
+	YYERROR("syntax error");
+    }
+
+//yyerrlab1:   /* here on error raised explicitly by an action */
+
+  if (yyerrstatus == 3)
+    {
+      /* if just tried and failed to reuse lookahead token after an error, discard it.  */
+
+      /* return failure if at end of input */
+      if (ctx->yychar == YYEOF) YYABORT;
+
+      ctx->yychar = YYEMPTY;
+    }
+
+  /* Else will try to reuse lookahead token
+     after shifting the error token.  */
+
+  yyerrstatus = 3;		/* Each real token shifted decrements this */
+
+  goto yyerrhandle;
+
+yyerrdefault:  /* current state does not do anything special for the error token. */
+
+#if 0
+  /* This is wrong; only states that explicitly want error tokens
+     should shift them.  */
+  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
+  if (yyn) goto yydefault;
+#endif
+
+yyerrpop:   /* pop the current state because it cannot handle the error token */
+
+  if (yyssp == yyss) YYABORT;
+  yyvsp--;
+  yystate = *--yyssp;
+
+
+yyerrhandle:
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yyerrdefault;
+
+  yyn += YYTERROR;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+    goto yyerrdefault;
+
+  yyn = yytable[yyn];
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+	goto yyerrpop;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrpop;
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  *++yyvsp = ctx->yylval;
+
+  yystate = yyn;
+  goto yynewstate;
+}
diff --git a/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-cfunc.c b/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-cfunc.c
new file mode 100644
index 00000000..57cb7c05
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-cfunc.c
@@ -0,0 +1,131 @@
+/*
+  Expression Evaluator Library (NS-EEL) v2
+  Copyright (C) 2004-2008 Cockos Incorporated
+  Copyright (C) 1999-2003 Nullsoft, Inc.
+  
+  nseel-cfunc.c: assembly/C implementation of operator/function templates
+  This file should be ideally compiled with optimizations towards "minimize size"
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#include "ns-eel-int.h"
+#include <math.h>
+#include <stdio.h>
+
+
+
+// these are used by our assembly code
+
+
+#define N 624
+#define M 397
+#define MATRIX_A 0x9908b0dfUL   /* constant vector a */
+#define UPPER_MASK 0x80000000UL /* most significant w-r bits */
+#define LOWER_MASK 0x7fffffffUL /* least significant r bits */
+
+static unsigned int genrand_int32(void)
+{
+
+    unsigned int y;
+    static unsigned int mag01[2]={0x0UL, MATRIX_A};
+    /* mag01[x] = x * MATRIX_A  for x=0,1 */
+
+    static unsigned int mt[N]; /* the array for the state vector  */
+    static int mti; /* mti==N+1 means mt[N] is not initialized */
+
+
+    if (!mti)
+    { 
+      unsigned int s=0x4141f00d;
+      mt[0]= s & 0xffffffffUL;
+      for (mti=1; mti<N; mti++) 
+      {
+          mt[mti] = 
+	      (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti); 
+          /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
+          /* In the previous versions, MSBs of the seed affect   */
+          /* only MSBs of the array mt[].                        */
+          /* 2002/01/09 modified by Makoto Matsumoto             */
+          mt[mti] &= 0xffffffffUL;
+          /* for >32 bit machines */
+      }
+    }
+
+    if (mti >= N) { /* generate N words at one time */
+        int kk;
+
+        for (kk=0;kk<N-M;kk++) {
+            y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
+            mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1UL];
+        }
+        for (;kk<N-1;kk++) {
+            y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
+            mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1UL];
+        }
+        y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
+        mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1UL];
+
+        mti = 0;
+    }
+  
+    y = mt[mti++];
+
+    /* Tempering */
+    y ^= (y >> 11);
+    y ^= (y << 7) & 0x9d2c5680UL;
+    y ^= (y << 15) & 0xefc60000UL;
+    y ^= (y >> 18);
+
+    return y;
+}
+
+
+
+//---------------------------------------------------------------------------------------------------------------
+EEL_F NSEEL_CGEN_CALL nseel_int_rand(EEL_F *f)
+{
+  EEL_F x=floor(*f);
+  if (x < 1.0) x=1.0;
+ 
+#ifdef NSEEL_EEL1_COMPAT_MODE 
+  return (EEL_F)(genrand_int32()%(int)x);
+#else
+  return (EEL_F) (genrand_int32()*(1.0/(double)0xFFFFFFFF)*x);
+#endif
+//  return (EEL_F)(rand()%EEL_F2int(x));
+}
+
+//---------------------------------------------------------------------------------------------------------------
+
+
+
+#ifdef __ppc__
+#include "asm-nseel-ppc-gcc.c"
+#else
+  #ifdef _MSC_VER
+    #ifdef _WIN64
+      //nasm
+    #else
+      #include "asm-nseel-x86-msvc.c"
+    #endif
+  #elif !defined(__LP64__)
+  #include "asm-nseel-x86-gcc.c"
+  #endif
+#endif
+
diff --git a/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-compiler.c b/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-compiler.c
new file mode 100644
index 00000000..da222179
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-compiler.c
@@ -0,0 +1,1791 @@
+/*
+  Expression Evaluator Library (NS-EEL) v2
+  Copyright (C) 2004-2008 Cockos Incorporated
+  Copyright (C) 1999-2003 Nullsoft, Inc.
+  
+  nseel-compiler.c
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+// for VirtualProtect
+
+#include "ns-eel-int.h"
+
+
+#include <string.h>
+#include <math.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#ifndef _WIN64
+  #ifndef __ppc__
+    #include <float.h>
+  #endif
+#endif
+
+#ifdef __APPLE__
+  #ifdef __LP64__
+    #define EEL_USE_MPROTECT
+  #endif
+#endif
+
+#ifdef EEL_USE_MPROTECT
+#include <sys/mman.h>
+#include <stdint.h>
+#include <unistd.h>
+#endif
+
+#ifdef NSEEL_EEL1_COMPAT_MODE
+
+#ifndef EEL_NO_CHANGE_FPFLAGS
+#define EEL_NO_CHANGE_FPFLAGS
+#endif
+
+#endif
+
+#ifndef _WIN64
+#if !defined(_RC_CHOP) && !defined(EEL_NO_CHANGE_FPFLAGS)
+
+#include <fpu_control.h>
+#define _RC_CHOP _FPU_RC_ZERO
+#define _MCW_RC _FPU_RC_ZERO
+static unsigned int _controlfp(unsigned int val, unsigned int mask)
+{
+   unsigned int ret;
+   _FPU_GETCW(ret);
+   if (mask)
+   {
+     ret&=~mask;
+     ret|=val;
+     _FPU_SETCW(ret);
+   }
+   return ret;
+}
+
+#endif
+#endif
+
+
+#ifdef __ppc__
+
+#define GLUE_MOV_EAX_DIRECTVALUE_SIZE 8
+static void GLUE_MOV_EAX_DIRECTVALUE_GEN(void *b, INT_PTR v) 
+{   
+    	unsigned int uv=(unsigned int)v;
+	unsigned short *p=(unsigned short *)b;
+
+        *p++ = 0x3C60; // addis r3, r0, hw
+	*p++ = (uv>>16)&0xffff;
+        *p++ = 0x6063; // ori r3, r3, lw
+	*p++ = uv&0xffff;
+}
+
+
+// mflr r5
+// stwu r5, -4(r1)
+const static unsigned int GLUE_FUNC_ENTER[2] = { 0x7CA802A6, 0x94A1FFFC };
+
+// lwz r5, 0(r1)
+// addi r1, r1, 4
+// mtlr r5
+const static unsigned int GLUE_FUNC_LEAVE[3] = { 0x80A10000, 0x38210004, 0x7CA803A6 };
+#define GLUE_FUNC_ENTER_SIZE sizeof(GLUE_FUNC_ENTER)
+#define GLUE_FUNC_LEAVE_SIZE sizeof(GLUE_FUNC_LEAVE)
+
+const static unsigned int GLUE_RET[]={0x4E800020}; // blr
+
+const static unsigned int GLUE_MOV_ESI_EDI=0x7E308B78; // mr r16, r17
+
+static int GLUE_RESET_ESI(char *out, void *ptr)
+{
+  if (out) memcpy(out,&GLUE_MOV_ESI_EDI,sizeof(GLUE_MOV_ESI_EDI));
+  return sizeof(GLUE_MOV_ESI_EDI);
+
+}
+
+
+
+// stwu r3, -4(r1)
+const static unsigned int GLUE_PUSH_EAX[1]={ 0x9461FFFC};
+
+// lwz r14, 0(r1)
+// addi r1, r1, 4
+const static unsigned int GLUE_POP_EBX[2]={ 0x81C10000, 0x38210004, };
+
+// lwz r15, 0(r1)
+// addi r1, r1, 4
+const static unsigned int GLUE_POP_ECX[2]={ 0x81E10000, 0x38210004 };
+
+
+static void GLUE_CALL_CODE(INT_PTR bp, INT_PTR cp) 
+{
+  __asm__(
+          "stmw r14, -80(r1)\n"
+          "mtctr %0\n"
+          "mr r17, %1\n" 
+	  "subi r17, r17, 8\n"
+          "mflr r5\n" 
+          "stw r5, -84(r1)\n"
+          "subi r1, r1, 88\n"
+          "bctrl\n"
+          "addi r1, r1, 88\n"
+          "lwz r5, -84(r1)\n"
+          "lmw r14, -80(r1)\n"
+          "mtlr r5\n"
+            ::"r" (cp), "r" (bp));
+};
+
+INT_PTR *EEL_GLUE_set_immediate(void *_p, void *newv)
+{
+// todo 64 bit ppc will take some work
+  unsigned int *p=(unsigned int *)_p;
+  while ((p[0]&0x0000FFFF) != 0x0000dead && 
+         (p[1]&0x0000FFFF) != 0x0000beef) p++;
+  p[0] = (p[0]&0xFFFF0000) | (((unsigned int)newv)>>16);
+  p[1] = (p[1]&0xFFFF0000) | (((unsigned int)newv)&0xFFFF);
+
+  return (INT_PTR*)++p;
+}
+
+
+#else
+
+//x86 specific code
+
+#define GLUE_FUNC_ENTER_SIZE 0
+#define GLUE_FUNC_LEAVE_SIZE 0
+const static unsigned int GLUE_FUNC_ENTER[1];
+const static unsigned int GLUE_FUNC_LEAVE[1];
+
+#if defined(_WIN64) || defined(__LP64__)
+#define GLUE_MOV_EAX_DIRECTVALUE_SIZE 10
+static void GLUE_MOV_EAX_DIRECTVALUE_GEN(void *b, INT_PTR v) {   
+  unsigned short *bb = (unsigned short *)b;
+  *bb++ =0xB848; 
+  *(INT_PTR *)bb = v; 
+}
+const static unsigned char  GLUE_PUSH_EAX[2]={	   0x50,0x50}; // push rax ; push rax (push twice to preserve alignment)
+const static unsigned char  GLUE_POP_EBX[2]={0x5F, 0x5f}; //pop rdi ; twice
+const static unsigned char  GLUE_POP_ECX[2]={0x59, 0x59 }; // pop rcx ; twice
+#else
+#define GLUE_MOV_EAX_DIRECTVALUE_SIZE 5
+static void GLUE_MOV_EAX_DIRECTVALUE_GEN(void *b, int v) 
+{   
+  *((unsigned char *)b) =0xB8; 
+  b= ((unsigned char *)b)+1;
+  *(int *)b = v; 
+}
+const static unsigned char  GLUE_PUSH_EAX[4]={0x83, 0xEC, 12,   0x50}; // sub esp, 12, push eax
+const static unsigned char  GLUE_POP_EBX[4]={0x5F, 0x83, 0xC4, 12}; //pop ebx, add esp, 12 // DI=5F, BX=0x5B;
+const static unsigned char  GLUE_POP_ECX[4]={0x59, 0x83, 0xC4, 12}; // pop ecx, add esp, 12
+
+#endif
+
+//const static unsigned short GLUE_MOV_ESI_EDI=0xF78B;
+const static unsigned char  GLUE_RET=0xC3;
+
+static int GLUE_RESET_ESI(unsigned char *out, void *ptr)
+{
+#if defined(_WIN64) || defined(__LP64__)
+  if (out)
+  {
+	  *out++ = 0x48;
+    *out++ = 0xBE; // mov rsi, constant64
+  	*(void **)out = ptr;
+    out+=sizeof(void *);
+  }
+  return 2+sizeof(void *);
+#else
+  if (out)
+  {
+    *out++ = 0xBE; // mov esi, constant
+    memcpy(out,&ptr,sizeof(void *));
+    out+=sizeof(void *);
+  }
+  return 1+sizeof(void *);
+#endif
+}
+
+static void GLUE_CALL_CODE(INT_PTR bp, INT_PTR cp) 
+{
+  #if defined(_WIN64) || defined(__LP64__)
+	  extern void win64_callcode(INT_PTR code);
+	  win64_callcode(cp);
+  #else // non-64 bit
+ #ifdef _MSC_VER
+    #ifndef EEL_NO_CHANGE_FPFLAGS
+      unsigned int old_v=_controlfp(0,0); 
+      _controlfp(_RC_CHOP,_MCW_RC);
+    #endif
+
+    __asm
+    {
+      mov eax, cp
+      pushad 
+      call eax
+      popad
+    };
+
+    #ifndef EEL_NO_CHANGE_FPFLAGS
+      _controlfp(old_v,_MCW_RC);
+    #endif
+
+#else // gcc x86
+  #ifndef EEL_NO_CHANGE_FPFLAGS
+    unsigned int old_v=_controlfp(0,0); 
+    _controlfp(_RC_CHOP,_MCW_RC);
+  #endif
+  __asm__("call *%%eax"::"a" (cp): "%ecx","%edx","%esi","%edi");
+  #ifndef EEL_NO_CHANGE_FPFLAGS
+    _controlfp(old_v,_MCW_RC);
+  #endif
+    #endif //gcc x86
+  #endif // 32bit
+}
+
+INT_PTR *EEL_GLUE_set_immediate(void *_p, void *newv)
+{
+  char *p=(char*)_p;
+  while (*(INT_PTR *)p != ~(INT_PTR)0) p++;
+  *(INT_PTR *)p = (INT_PTR)newv;
+  return ((INT_PTR*)p)+1;
+}
+
+#endif
+
+
+static void *GLUE_realAddress(void *fn, void *fn_e, int *size)
+{
+#if defined(_MSC_VER) || defined(__LP64__)
+
+  unsigned char *p;
+
+#if defined(_DEBUG) && !defined(__LP64__)
+  if (*(unsigned char *)fn == 0xE9) // this means jump to the following address
+  {
+    fn = ((unsigned char *)fn) + *(int *)((char *)fn+1) + 5;
+  }
+#endif
+
+  // this may not work in debug mode
+  p=(unsigned char *)fn;
+  for (;;)
+  {
+    int a;
+    for (a=0;a<12;a++)
+    {
+      if (p[a] != (a?0x90:0x89)) break;
+    }
+    if (a>=12)
+    {
+      *size = (char *)p - (char *)fn;
+    //  if (*size<0) MessageBox(NULL,"expect poof","a",0);
+      return fn;
+    }
+    p++;
+  }
+#else
+  char *p=(char *)fn_e - sizeof(GLUE_RET);
+  if (p <= (char *)fn) *size=0;
+  else
+  {
+    while (p > (char *)fn && memcmp(p,&GLUE_RET,sizeof(GLUE_RET))) p-=sizeof(GLUE_RET);
+    *size = p - (char *)fn;
+  }
+  return fn;
+#endif
+}
+
+
+
+static int nseel_evallib_stats[5]; // source bytes, static code bytes, call code bytes, data bytes, segments
+int *NSEEL_getstats()
+{
+  return nseel_evallib_stats;
+}
+EEL_F *NSEEL_getglobalregs()
+{
+  return nseel_globalregs;
+}
+
+// this stuff almost works
+static int findByteOffsetInSource(compileContext *ctx, int byteoffs,int *destoffs)
+{
+	int x;
+	if (!ctx->compileLineRecs || !ctx->compileLineRecs_size) return *destoffs=0;
+	if (byteoffs < ctx->compileLineRecs[0].destByteCount) 
+	{
+		*destoffs=0;
+		return 1;
+	}
+	for (x = 0; x < ctx->compileLineRecs_size-1; x ++)
+	{
+		if (byteoffs >= ctx->compileLineRecs[x].destByteCount &&
+		    byteoffs < ctx->compileLineRecs[x+1].destByteCount) break;
+	}
+	*destoffs=ctx->compileLineRecs[(x&&x==ctx->compileLineRecs_size-1)?x-1:x].srcByteCount;
+
+	return x+2;
+}
+
+
+static void onCompileNewLine(compileContext *ctx, int srcBytes, int destBytes)
+{
+	if (!ctx->compileLineRecs || ctx->compileLineRecs_size >= ctx->compileLineRecs_alloc)
+	{
+		ctx->compileLineRecs_alloc = ctx->compileLineRecs_size+1024;
+		ctx->compileLineRecs = (lineRecItem *)realloc(ctx->compileLineRecs,sizeof(lineRecItem)*ctx->compileLineRecs_alloc);
+	}
+	if (ctx->compileLineRecs)
+	{
+		ctx->compileLineRecs[ctx->compileLineRecs_size].srcByteCount=srcBytes;
+		ctx->compileLineRecs[ctx->compileLineRecs_size++].destByteCount=destBytes;
+	}
+}
+
+
+
+#define LLB_DSIZE (65536-64)
+typedef struct _llBlock {
+	struct _llBlock *next;
+  int sizeused;
+	char block[LLB_DSIZE];
+} llBlock;
+
+typedef struct _startPtr {
+  struct _startPtr *next;
+  void *startptr;
+} startPtr;
+
+typedef struct {
+  void *workTable;
+
+  llBlock *blocks;
+  void *code;
+  int code_stats[4];
+} codeHandleType;
+
+#ifndef NSEEL_MAX_TEMPSPACE_ENTRIES
+#define NSEEL_MAX_TEMPSPACE_ENTRIES 2048
+#endif
+
+static void *__newBlock(llBlock **start,int size);
+
+#define newTmpBlock(x) __newTmpBlock((llBlock **)&ctx->tmpblocks_head,x)
+#define newBlock(x,a) __newBlock_align(ctx,x,a)
+
+static void *__newTmpBlock(llBlock **start, int size)
+{
+  void *p=__newBlock(start,size+4);
+  if (p && size>=0) *((int *)p) = size;
+  return p;
+}
+
+static void *__newBlock_align(compileContext *ctx, int size, int align) // makes sure block is aligned to 32 byte boundary, for code
+{
+  int a1=align-1;
+  char *p=(char*)__newBlock((llBlock **)&ctx->blocks_head,size+a1);
+  return p+((align-(((INT_PTR)p)&a1))&a1);
+}
+
+static void freeBlocks(llBlock **start);
+
+#define DECL_ASMFUNC(x)         \
+  void nseel_asm_##x(void);        \
+  void nseel_asm_##x##_end(void);    \
+
+  DECL_ASMFUNC(sin)
+  DECL_ASMFUNC(cos)
+  DECL_ASMFUNC(tan)
+  DECL_ASMFUNC(1pdd)
+  DECL_ASMFUNC(2pdd)
+  DECL_ASMFUNC(2pdds)
+  DECL_ASMFUNC(1pp)
+  DECL_ASMFUNC(2pp)
+  DECL_ASMFUNC(sqr)
+  DECL_ASMFUNC(sqrt)
+  DECL_ASMFUNC(log)
+  DECL_ASMFUNC(log10)
+  DECL_ASMFUNC(abs)
+  DECL_ASMFUNC(min)
+  DECL_ASMFUNC(max)
+  DECL_ASMFUNC(sig)
+  DECL_ASMFUNC(sign)
+  DECL_ASMFUNC(band)
+  DECL_ASMFUNC(bor)
+  DECL_ASMFUNC(bnot)
+  DECL_ASMFUNC(if)
+  DECL_ASMFUNC(repeat)
+  DECL_ASMFUNC(repeatwhile)
+  DECL_ASMFUNC(equal)
+  DECL_ASMFUNC(notequal)
+  DECL_ASMFUNC(below)
+  DECL_ASMFUNC(above)
+  DECL_ASMFUNC(beloweq)
+  DECL_ASMFUNC(aboveeq)
+  DECL_ASMFUNC(assign)
+  DECL_ASMFUNC(add)
+  DECL_ASMFUNC(sub)
+  DECL_ASMFUNC(add_op)
+  DECL_ASMFUNC(sub_op)
+  DECL_ASMFUNC(mul)
+  DECL_ASMFUNC(div)
+  DECL_ASMFUNC(mul_op)
+  DECL_ASMFUNC(div_op)
+  DECL_ASMFUNC(mod)
+  DECL_ASMFUNC(mod_op)
+  DECL_ASMFUNC(or)
+  DECL_ASMFUNC(and)
+  DECL_ASMFUNC(or_op)
+  DECL_ASMFUNC(and_op)
+  DECL_ASMFUNC(uplus)
+  DECL_ASMFUNC(uminus)
+  DECL_ASMFUNC(invsqrt)
+  DECL_ASMFUNC(exec2)
+
+static void NSEEL_PProc_GRAM(void *data, int data_size, compileContext *ctx)
+{
+  if (data_size>0) EEL_GLUE_set_immediate(data, ctx->gram_blocks);
+}
+
+
+static EEL_F g_signs[2]={1.0,-1.0};
+static EEL_F negativezeropointfive=-0.5f;
+static EEL_F onepointfive=1.5f;
+static EEL_F g_closefact = NSEEL_CLOSEFACTOR;
+static const EEL_F eel_zero=0.0, eel_one=1.0;
+
+//#if defined(_MSC_VER) && _MSC_VER >= 1400
+//static double __floor(double a) { return floor(a); }
+//#endif
+
+static double eel1band(double a, double b)
+{
+  return (fabs(a)>g_closefact && fabs(b) > g_closefact) ? 1.0 : 0.0;
+}
+static double eel1bor(double a, double b)
+{
+  return (fabs(a)>g_closefact || fabs(b) > g_closefact) ? 1.0 : 0.0;
+}
+
+static double eel1sigmoid(double x, double constraint)
+{
+  double t = (1+exp(-x * (constraint)));
+  return fabs(t)>g_closefact ? 1.0/t : 0;
+}
+
+
+EEL_F NSEEL_CGEN_CALL nseel_int_rand(EEL_F *f);
+
+static functionType fnTable1[] = {
+  { "_if",     nseel_asm_if,nseel_asm_if_end,    3,  {&g_closefact} },
+  { "_and",   nseel_asm_band,nseel_asm_band_end,  2 } ,
+  { "_or",    nseel_asm_bor,nseel_asm_bor_end,   2 } ,
+  { "loop", nseel_asm_repeat,nseel_asm_repeat_end, 2 },
+  { "while", nseel_asm_repeatwhile,nseel_asm_repeatwhile_end, 1 },
+
+#ifdef __ppc__
+  { "_not",   nseel_asm_bnot,nseel_asm_bnot_end,  1, {&g_closefact,&eel_zero,&eel_one} } ,
+  { "_equal",  nseel_asm_equal,nseel_asm_equal_end, 2, {&g_closefact,&eel_zero, &eel_one} },
+  { "_noteq",  nseel_asm_notequal,nseel_asm_notequal_end, 2, {&g_closefact,&eel_one,&eel_zero} },
+  { "_below",  nseel_asm_below,nseel_asm_below_end, 2, {&eel_zero, &eel_one} },
+  { "_above",  nseel_asm_above,nseel_asm_above_end, 2, {&eel_zero, &eel_one}  },
+  { "_beleq",  nseel_asm_beloweq,nseel_asm_beloweq_end, 2, {&eel_zero, &eel_one}  },
+  { "_aboeq",  nseel_asm_aboveeq,nseel_asm_aboveeq_end, 2, {&eel_zero, &eel_one} },
+#else
+  { "_not",   nseel_asm_bnot,nseel_asm_bnot_end,  1, {&g_closefact} } ,
+  { "_equal",  nseel_asm_equal,nseel_asm_equal_end, 2, {&g_closefact} },
+  { "_noteq",  nseel_asm_notequal,nseel_asm_notequal_end, 2, {&g_closefact} },
+  { "_below",  nseel_asm_below,nseel_asm_below_end, 2 },
+  { "_above",  nseel_asm_above,nseel_asm_above_end, 2 },
+  { "_beleq",  nseel_asm_beloweq,nseel_asm_beloweq_end, 2 },
+  { "_aboeq",  nseel_asm_aboveeq,nseel_asm_aboveeq_end, 2 },
+#endif
+
+  { "_set",nseel_asm_assign,nseel_asm_assign_end,2},
+  { "_mod",nseel_asm_mod,nseel_asm_mod_end,2},
+  { "_mulop",nseel_asm_mul_op,nseel_asm_mul_op_end,2},
+  { "_divop",nseel_asm_div_op,nseel_asm_div_op_end,2},
+  { "_orop",nseel_asm_or_op,nseel_asm_or_op_end,2},
+  { "_andop",nseel_asm_and_op,nseel_asm_and_op_end,2},
+  { "_addop",nseel_asm_add_op,nseel_asm_add_op_end,2},
+  { "_subop",nseel_asm_sub_op,nseel_asm_sub_op_end,2},
+  { "_modop",nseel_asm_mod_op,nseel_asm_mod_op_end,2},
+
+
+#ifdef __ppc__
+   { "sin",   nseel_asm_1pdd,nseel_asm_1pdd_end,   1, {&sin} },
+   { "cos",    nseel_asm_1pdd,nseel_asm_1pdd_end,   1, {&cos} },
+   { "tan",    nseel_asm_1pdd,nseel_asm_1pdd_end,   1, {&tan}  },
+#else
+   { "sin",   nseel_asm_sin,nseel_asm_sin_end,   1 },
+   { "cos",    nseel_asm_cos,nseel_asm_cos_end,   1 },
+   { "tan",    nseel_asm_tan,nseel_asm_tan_end,   1 },
+#endif
+   { "asin",   nseel_asm_1pdd,nseel_asm_1pdd_end,  1, {&asin}, },
+   { "acos",   nseel_asm_1pdd,nseel_asm_1pdd_end,  1, {&acos}, },
+   { "atan",   nseel_asm_1pdd,nseel_asm_1pdd_end,  1, {&atan}, },
+   { "atan2",  nseel_asm_2pdd,nseel_asm_2pdd_end, 2, {&atan2}, },
+   { "sqr",    nseel_asm_sqr,nseel_asm_sqr_end,   1 },
+#ifdef __ppc__
+   { "sqrt",   nseel_asm_1pdd,nseel_asm_1pdd_end,  1, {&sqrt}, },
+#else
+   { "sqrt",   nseel_asm_sqrt,nseel_asm_sqrt_end,  1 },
+#endif
+   { "pow",    nseel_asm_2pdd,nseel_asm_2pdd_end,   2, {&pow}, },
+   { "_powop",    nseel_asm_2pdds,nseel_asm_2pdds_end,   2, {&pow}, },
+   { "exp",    nseel_asm_1pdd,nseel_asm_1pdd_end,   1, {&exp}, },
+#ifdef __ppc__
+   { "log",    nseel_asm_1pdd,nseel_asm_1pdd_end,   1, {&log} },
+   { "log10",  nseel_asm_1pdd,nseel_asm_1pdd_end, 1, {&log10} },
+#else
+   { "log",    nseel_asm_log,nseel_asm_log_end,   1, },
+   { "log10",  nseel_asm_log10,nseel_asm_log10_end, 1, },
+#endif
+   { "abs",    nseel_asm_abs,nseel_asm_abs_end,   1 },
+   { "min",    nseel_asm_min,nseel_asm_min_end,   2 },
+   { "max",    nseel_asm_max,nseel_asm_max_end,   2 },
+#ifdef __ppc__
+   { "sign",   nseel_asm_sign,nseel_asm_sign_end,  1, {&eel_zero}} ,
+#else
+   { "sign",   nseel_asm_sign,nseel_asm_sign_end,  1, {&g_signs}} ,
+#endif
+	 { "rand",   nseel_asm_1pp,nseel_asm_1pp_end,  1, {&nseel_int_rand}, } ,
+
+//#if defined(_MSC_VER) && _MSC_VER >= 1400
+//   { "floor",  nseel_asm_1pdd,nseel_asm_1pdd_end, 1, {&__floor} },
+//#else
+//   { "floor",  nseel_asm_1pdd,nseel_asm_1pdd_end, 1, {&floor} },
+//#endif
+   { "ceil",   nseel_asm_1pdd,nseel_asm_1pdd_end,  1, {&ceil} },
+#ifdef __ppc__
+   { "invsqrt",   nseel_asm_invsqrt,nseel_asm_invsqrt_end,  1,  },
+#else
+   { "invsqrt",   nseel_asm_invsqrt,nseel_asm_invsqrt_end,  1, {&negativezeropointfive, &onepointfive} },
+#endif
+
+  { "sigmoid", nseel_asm_2pdd,nseel_asm_2pdd_end, 2, {&eel1sigmoid}, },
+
+  // these differ from _and/_or, they always evaluate both...
+  { "band",  nseel_asm_2pdd,nseel_asm_2pdd_end, 2, {&eel1band}, },
+  { "bor",  nseel_asm_2pdd,nseel_asm_2pdd_end, 2, {&eel1bor}, },
+
+  {"exec2",nseel_asm_exec2,nseel_asm_exec2_end,2},
+  {"exec3",nseel_asm_exec2,nseel_asm_exec2_end,3},
+   {"_mem",_asm_megabuf,_asm_megabuf_end,1,{&g_closefact,&__NSEEL_RAMAlloc},NSEEL_PProc_RAM},
+  {"_gmem",_asm_megabuf,_asm_megabuf_end,1,{&g_closefact,&__NSEEL_RAMAllocGMEM},NSEEL_PProc_GRAM},
+  {"freembuf",_asm_generic1parm,_asm_generic1parm_end,1,{&__NSEEL_RAM_MemFree},NSEEL_PProc_RAM},
+  {"memcpy",_asm_generic3parm,_asm_generic3parm_end,3,{&__NSEEL_RAM_MemCpy},NSEEL_PProc_RAM},
+  {"memset",_asm_generic3parm,_asm_generic3parm_end,3,{&__NSEEL_RAM_MemSet},NSEEL_PProc_RAM},
+};
+
+static functionType *fnTableUser;
+static int fnTableUser_size;
+
+functionType *nseel_getFunctionFromTable(int idx)
+{
+  if (idx<0) return 0;
+  if (idx>=sizeof(fnTable1)/sizeof(fnTable1[0]))
+  {
+    idx -= sizeof(fnTable1)/sizeof(fnTable1[0]);
+    if (!fnTableUser || idx >= fnTableUser_size) return 0;
+    return fnTableUser+idx;
+  }
+  return fnTable1+idx;
+}
+
+int NSEEL_init() // returns 0 on success
+{
+  NSEEL_quit();
+  return 0;
+}
+
+void NSEEL_addfunctionex2(const char *name, int nparms, char *code_startaddr, int code_len, void *pproc, void *fptr, void *fptr2)
+{
+  if (!fnTableUser || !(fnTableUser_size&7))
+  {
+    fnTableUser=(functionType *)realloc(fnTableUser,(fnTableUser_size+8)*sizeof(functionType));
+  }
+  if (fnTableUser)
+  {
+    memset(&fnTableUser[fnTableUser_size],0,sizeof(functionType));
+    fnTableUser[fnTableUser_size].nParams = nparms;
+    fnTableUser[fnTableUser_size].name = name;
+    fnTableUser[fnTableUser_size].afunc = code_startaddr;
+    fnTableUser[fnTableUser_size].func_e = code_startaddr + code_len;
+    fnTableUser[fnTableUser_size].pProc = (NSEEL_PPPROC) pproc;
+    fnTableUser[fnTableUser_size].replptrs[0]=fptr;
+    fnTableUser[fnTableUser_size].replptrs[1]=fptr2;
+    fnTableUser_size++;
+  }
+}
+
+void NSEEL_quit()
+{
+  free(fnTableUser);
+  fnTableUser_size=0;
+  fnTableUser=0;
+}
+
+//---------------------------------------------------------------------------------------------------------------
+static void freeBlocks(llBlock **start)
+{
+  llBlock *s=*start;
+  *start=0;
+  while (s)
+  {
+    llBlock *llB = s->next;
+#ifdef _WIN32
+		VirtualFree(s, 0 /*LLB_DSIZE*/, MEM_RELEASE);
+#else
+    free(s);
+#endif
+    s=llB;
+  }
+}
+
+//---------------------------------------------------------------------------------------------------------------
+static void *__newBlock(llBlock **start, int size)
+{
+  llBlock *llb;
+  int alloc_size;
+  if (*start && (LLB_DSIZE - (*start)->sizeused) >= size)
+  {
+    void *t=(*start)->block+(*start)->sizeused;
+    (*start)->sizeused+=(size+7)&~7;
+    return t;
+  }
+
+  alloc_size=sizeof(llBlock);
+  if ((int)size > LLB_DSIZE) alloc_size += size - LLB_DSIZE;
+ 
+#ifdef _WIN32
+	llb = (llBlock *)VirtualAlloc(NULL, alloc_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
+#else
+	llb = (llBlock *)malloc(alloc_size); // grab bigger block if absolutely necessary (heh)
+#endif
+#if defined(EEL_USE_MPROTECT)
+  {
+    static int pagesize = 0;
+    if (!pagesize)
+    {
+      pagesize=sysconf(_SC_PAGESIZE);
+      if (!pagesize) pagesize=4096;
+    }
+    uintptr_t offs,eoffs;
+    offs=((uintptr_t)llb)&~(pagesize-1);
+    eoffs=((uintptr_t)llb + alloc_size + pagesize-1)&~(pagesize-1);
+    mprotect((void*)offs,eoffs-offs,PROT_WRITE|PROT_READ|PROT_EXEC);
+  }
+#endif
+  llb->sizeused=(size+7)&~7;
+  llb->next = *start;  
+  *start = llb;
+  return llb->block;
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+INT_PTR nseel_createCompiledValue(compileContext *ctx, EEL_F value, EEL_F *addrValue)
+{
+  unsigned char *block;
+
+  block=(unsigned char *)newTmpBlock(GLUE_MOV_EAX_DIRECTVALUE_SIZE);
+
+  if (addrValue == NULL)
+  {
+    *(addrValue = (EEL_F *)newBlock(sizeof(EEL_F),sizeof(EEL_F))) = value;
+    ctx->l_stats[3]+=sizeof(EEL_F);
+  }
+
+  GLUE_MOV_EAX_DIRECTVALUE_GEN(block+4,(INT_PTR)addrValue);
+
+  return ((INT_PTR)(block));
+
+}
+
+//---------------------------------------------------------------------------------------------------------------
+static void *nseel_getFunctionAddress(int fntype, int fn, int *size, NSEEL_PPPROC *pProc, void ***replList)
+{
+  *replList=0;
+  switch (fntype)
+	{
+  	case MATH_SIMPLE:
+	  	switch (fn)
+			{
+			  case FN_ASSIGN:
+				  return GLUE_realAddress(nseel_asm_assign,nseel_asm_assign_end,size);
+			  case FN_ADD:
+				  return GLUE_realAddress(nseel_asm_add,nseel_asm_add_end,size);
+			  case FN_SUB:
+				  return GLUE_realAddress(nseel_asm_sub,nseel_asm_sub_end,size);
+			  case FN_MULTIPLY:
+				  return GLUE_realAddress(nseel_asm_mul,nseel_asm_mul_end,size);
+			  case FN_DIVIDE:
+				  return GLUE_realAddress(nseel_asm_div,nseel_asm_div_end,size);
+			  case FN_MODULO:
+				  return GLUE_realAddress(nseel_asm_exec2,nseel_asm_exec2_end,size);
+			  case FN_AND:
+				  return GLUE_realAddress(nseel_asm_and,nseel_asm_and_end,size);
+			  case FN_OR:
+				  return GLUE_realAddress(nseel_asm_or,nseel_asm_or_end,size);
+			  case FN_UPLUS:
+				  return GLUE_realAddress(nseel_asm_uplus,nseel_asm_uplus_end,size);
+			  case FN_UMINUS:
+				  return GLUE_realAddress(nseel_asm_uminus,nseel_asm_uminus_end,size);
+			}
+	  case MATH_FN:
+      {
+        functionType *p=nseel_getFunctionFromTable(fn);
+		    if (p) 
+        {
+          *replList=p->replptrs;
+          *pProc=p->pProc;
+          return GLUE_realAddress(p->afunc,p->func_e,size);
+        }
+      }
+	}
+
+  *size=0;
+  return 0;
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+INT_PTR nseel_createCompiledFunction3(compileContext *ctx, int fntype, INT_PTR fn, INT_PTR code1, INT_PTR code2, INT_PTR code3)
+{
+  int sizes1=((int *)code1)[0];
+  int sizes2=((int *)code2)[0];
+  int sizes3=((int *)code3)[0];
+
+  if (fntype == MATH_FN && fn == 0) // special case: IF
+  {
+    void *func3;
+    int size;
+    INT_PTR *ptr;
+    char *block;
+
+    unsigned char *newblock2,*newblock3;
+    unsigned char *p;
+
+    p=newblock2=newBlock(sizes2+sizeof(GLUE_RET)+GLUE_FUNC_ENTER_SIZE+GLUE_FUNC_LEAVE_SIZE,32);
+    memcpy(p,&GLUE_FUNC_ENTER,GLUE_FUNC_ENTER_SIZE); p+=GLUE_FUNC_ENTER_SIZE;
+    memcpy(p,(char*)code2+4,sizes2); p+=sizes2;
+    memcpy(p,&GLUE_FUNC_LEAVE,GLUE_FUNC_LEAVE_SIZE); p+=GLUE_FUNC_LEAVE_SIZE;
+    memcpy(p,&GLUE_RET,sizeof(GLUE_RET)); p+=sizeof(GLUE_RET);
+
+    p=newblock3=newBlock(sizes3+sizeof(GLUE_RET)+GLUE_FUNC_ENTER_SIZE+GLUE_FUNC_LEAVE_SIZE,32);
+    memcpy(p,&GLUE_FUNC_ENTER,GLUE_FUNC_ENTER_SIZE); p+=GLUE_FUNC_ENTER_SIZE;
+    memcpy(p,(char*)code3+4,sizes3); p+=sizes3;
+    memcpy(p,&GLUE_FUNC_LEAVE,GLUE_FUNC_LEAVE_SIZE); p+=GLUE_FUNC_LEAVE_SIZE;
+    memcpy(p,&GLUE_RET,sizeof(GLUE_RET)); p+=sizeof(GLUE_RET);
+
+    ctx->l_stats[2]+=sizes2+sizes3+sizeof(GLUE_RET)*2;
+    
+    func3 = GLUE_realAddress(nseel_asm_if,nseel_asm_if_end,&size);
+
+    block=(char *)newTmpBlock(sizes1+size);
+
+    memcpy(block+4,(char*)code1+4,sizes1);
+    ptr=(INT_PTR *)(block+4+sizes1);
+    memcpy(ptr,func3,size);
+
+    ptr=EEL_GLUE_set_immediate(ptr,&g_closefact);
+    ptr=EEL_GLUE_set_immediate(ptr,newblock2);
+    EEL_GLUE_set_immediate(ptr,newblock3);
+
+    ctx->computTableTop++;
+
+    return (INT_PTR)block;
+
+  }
+  else
+  {
+    int size2;
+    unsigned char *block;
+    unsigned char *outp;
+
+    void *myfunc;
+    NSEEL_PPPROC preProc=0;
+    void **repl;
+  
+    myfunc = nseel_getFunctionAddress(fntype, fn, &size2, &preProc,&repl);
+
+    block=(unsigned char *)newTmpBlock(size2+sizes1+sizes2+sizes3+
+      sizeof(GLUE_PUSH_EAX) + 
+      sizeof(GLUE_PUSH_EAX) +
+      sizeof(GLUE_POP_EBX) + 
+      sizeof(GLUE_POP_ECX));
+
+    outp=block+4;
+    memcpy(outp,(char*)code1+4,sizes1); 
+    outp+=sizes1;
+    memcpy(outp,&GLUE_PUSH_EAX,sizeof(GLUE_PUSH_EAX)); outp+=sizeof(GLUE_PUSH_EAX);
+    memcpy(outp,(char*)code2+4,sizes2); 
+    outp+=sizes2;
+    memcpy(outp,&GLUE_PUSH_EAX,sizeof(GLUE_PUSH_EAX)); outp+=sizeof(GLUE_PUSH_EAX);
+    memcpy(outp,(char*)code3+4,sizes3); 
+    outp+=sizes3;
+    memcpy(outp,&GLUE_POP_EBX,sizeof(GLUE_POP_EBX)); outp+=sizeof(GLUE_POP_EBX);
+    memcpy(outp,&GLUE_POP_ECX,sizeof(GLUE_POP_ECX)); outp+=sizeof(GLUE_POP_ECX);
+
+    memcpy(outp,myfunc,size2);
+    if (preProc) preProc(outp,size2,ctx);
+    if (repl)
+    {
+      if (repl[0]) outp=(unsigned char *)EEL_GLUE_set_immediate(outp,repl[0]);
+      if (repl[1]) outp=(unsigned char *)EEL_GLUE_set_immediate(outp,repl[1]);
+      if (repl[2]) outp=(unsigned char *)EEL_GLUE_set_immediate(outp,repl[2]);
+      if (repl[3]) outp=(unsigned char *)EEL_GLUE_set_immediate(outp,repl[3]);
+    }
+
+    ctx->computTableTop++;
+
+    return ((INT_PTR)(block));  
+  }
+}
+
+//---------------------------------------------------------------------------------------------------------------
+INT_PTR nseel_createCompiledFunction2(compileContext *ctx, int fntype, INT_PTR fn, INT_PTR code1, INT_PTR code2)
+{
+  int size2;
+  unsigned char *outp;
+  void *myfunc;
+  int sizes1=((int *)code1)[0];
+  int sizes2=((int *)code2)[0];
+  if (fntype == MATH_FN && (fn == 1 || fn == 2 || fn == 3)) // special case: LOOP/BOR/BAND
+  {
+    void *func3;
+    int size;
+    INT_PTR *ptr;
+    char *block;
+
+    unsigned char *newblock2, *p;
+
+    p=newblock2=newBlock(sizes2+sizeof(GLUE_RET)+GLUE_FUNC_ENTER_SIZE+GLUE_FUNC_LEAVE_SIZE,32);
+    memcpy(p,&GLUE_FUNC_ENTER,GLUE_FUNC_ENTER_SIZE); p+=GLUE_FUNC_ENTER_SIZE;
+    memcpy(p,(char*)code2+4,sizes2); p+=sizes2;
+    memcpy(p,&GLUE_FUNC_LEAVE,GLUE_FUNC_LEAVE_SIZE); p+=GLUE_FUNC_LEAVE_SIZE;
+    memcpy(p,&GLUE_RET,sizeof(GLUE_RET)); p+=sizeof(GLUE_RET);
+
+    ctx->l_stats[2]+=sizes2+2;
+    
+    if (fn == 1) func3 = GLUE_realAddress(nseel_asm_band,nseel_asm_band_end,&size);
+    else if (fn == 3) func3 = GLUE_realAddress(nseel_asm_repeat,nseel_asm_repeat_end,&size);
+    else func3 = GLUE_realAddress(nseel_asm_bor,nseel_asm_bor_end,&size);
+
+    block=(char *)newTmpBlock(sizes1+size);
+    memcpy(block+4,(char*)code1+4,sizes1);
+    ptr=(INT_PTR *)(block+4+sizes1);
+    memcpy(ptr,func3,size);
+
+    if (fn!=3) ptr=EEL_GLUE_set_immediate(ptr,&g_closefact); // for or/and
+    ptr=EEL_GLUE_set_immediate(ptr,newblock2);
+    if (fn!=3) ptr=EEL_GLUE_set_immediate(ptr,&g_closefact); // for or/and
+#ifdef __ppc__
+    if (fn!=3) // for or/and on ppc we need a one
+    {
+      ptr=EEL_GLUE_set_immediate(ptr,&eel_one);
+    }
+#endif
+
+    ctx->computTableTop++;
+    return (INT_PTR)block;
+  }
+
+  {
+    NSEEL_PPPROC preProc=0;
+    unsigned char *block;
+    void **repl;
+    myfunc = nseel_getFunctionAddress(fntype, fn, &size2,&preProc,&repl);
+
+    block=(unsigned char *)newTmpBlock(size2+sizes1+sizes2+sizeof(GLUE_PUSH_EAX)+sizeof(GLUE_POP_EBX));
+
+    outp=block+4;
+    memcpy(outp,(char*)code1+4,sizes1); 
+    outp+=sizes1;
+    memcpy(outp,&GLUE_PUSH_EAX,sizeof(GLUE_PUSH_EAX)); outp+=sizeof(GLUE_PUSH_EAX);
+    memcpy(outp,(char*)code2+4,sizes2); 
+    outp+=sizes2;
+    memcpy(outp,&GLUE_POP_EBX,sizeof(GLUE_POP_EBX)); outp+=sizeof(GLUE_POP_EBX);
+
+    memcpy(outp,myfunc,size2);
+    if (preProc) preProc(outp,size2,ctx);
+    if (repl)
+    {
+      if (repl[0]) outp=(unsigned char *)EEL_GLUE_set_immediate(outp,repl[0]);
+      if (repl[1]) outp=(unsigned char *)EEL_GLUE_set_immediate(outp,repl[1]);
+      if (repl[2]) outp=(unsigned char *)EEL_GLUE_set_immediate(outp,repl[2]);
+      if (repl[3]) outp=(unsigned char *)EEL_GLUE_set_immediate(outp,repl[3]);
+    }
+
+    ctx->computTableTop++;
+
+    return ((INT_PTR)(block));
+  }
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+INT_PTR nseel_createCompiledFunction1(compileContext *ctx, int fntype, INT_PTR fn, INT_PTR code)
+{
+  NSEEL_PPPROC preProc=0;
+  int size,size2;
+  char *block;
+  void *myfunc;
+  void *func1;
+  
+  size =((int *)code)[0];
+  func1 = (void *)(code+4);
+
+ 
+  if (fntype == MATH_FN && fn == 4) // special case: while
+  {
+    void *func3;
+    INT_PTR *ptr;
+
+    unsigned char *newblock2, *p;
+
+    p=newblock2=newBlock(size+sizeof(GLUE_RET)+GLUE_FUNC_ENTER_SIZE+GLUE_FUNC_LEAVE_SIZE,32);
+    memcpy(p,&GLUE_FUNC_ENTER,GLUE_FUNC_ENTER_SIZE); p+=GLUE_FUNC_ENTER_SIZE;
+    memcpy(p,func1,size); p+=size;
+    memcpy(p,&GLUE_FUNC_LEAVE,GLUE_FUNC_LEAVE_SIZE); p+=GLUE_FUNC_LEAVE_SIZE;
+    memcpy(p,&GLUE_RET,sizeof(GLUE_RET)); p+=sizeof(GLUE_RET);
+
+    ctx->l_stats[2]+=size+2;
+    
+    func3 = GLUE_realAddress(nseel_asm_repeatwhile,nseel_asm_repeatwhile_end,&size);
+
+    block=(char *)newTmpBlock(size);
+  	ptr = (INT_PTR *)(block+4);
+    memcpy(ptr,func3,size);
+    ptr=EEL_GLUE_set_immediate(ptr,newblock2); 
+    EEL_GLUE_set_immediate(ptr,&g_closefact); 
+
+    ctx->computTableTop++;
+    return (INT_PTR)block;
+  }
+
+  {
+    void **repl;
+	  myfunc = nseel_getFunctionAddress(fntype, fn, &size2,&preProc,&repl);
+
+	  block=(char *)newTmpBlock(size+size2);
+
+	  memcpy(block+4, func1, size);
+	  memcpy(block+size+4,myfunc,size2);
+	  if (preProc) preProc(block+size+4,size2,ctx);
+    if (repl)
+    {
+      unsigned char *outp=(unsigned char *)block+size+4;
+      if (repl[0]) outp=(unsigned char *)EEL_GLUE_set_immediate(outp,repl[0]);
+      if (repl[1]) outp=(unsigned char *)EEL_GLUE_set_immediate(outp,repl[1]);
+      if (repl[2]) outp=(unsigned char *)EEL_GLUE_set_immediate(outp,repl[2]);
+      if (repl[3]) outp=(unsigned char *)EEL_GLUE_set_immediate(outp,repl[3]);
+    }
+
+	  ctx->computTableTop++;
+
+	  return ((INT_PTR)(block));
+  }
+}
+
+
+static char *preprocessCode(compileContext *ctx, char *expression)
+{
+  char *expression_start=expression;
+  int len=0;
+  int alloc_len=strlen(expression)+1+64;
+  char *buf=(char *)malloc(alloc_len);
+  int semicnt=0;
+  // we need to call onCompileNewLine for each new line we get
+ 
+  //onCompileNewLine(ctx, 
+
+  while (*expression)
+  {
+    if (len > alloc_len-64)
+    {
+      alloc_len = len+128;
+      buf=(char*)realloc(buf,alloc_len);
+    }
+
+    if (expression[0] == '/')
+    {
+      if (expression[1] == '/')
+      {
+        expression+=2;
+        while (expression[0] && expression[0] != '\n') expression++;
+	continue;
+      }
+      else if (expression[1] == '*')
+      {
+        expression+=2;
+        while (expression[0] && (expression[0] != '*' || expression[1] != '/')) 
+	{
+		if (expression[0] == '\n') onCompileNewLine(ctx,expression+1-expression_start,len);
+		expression++;
+	}
+        if (expression[0]) expression+=2; // at this point we KNOW expression[0]=* and expression[1]=/
+	continue;
+      }
+    }
+    
+    if (expression[0] == '$')
+    {
+      if (toupper(expression[1]) == 'X')
+      {
+        char *p=expression+2;
+        unsigned int v=strtoul(expression+2,&p,16);
+        char tmp[64];
+        expression=p;
+
+        sprintf(tmp,"%u",v);
+        memcpy(buf+len,tmp,strlen(tmp));
+        len+=strlen(tmp);
+        ctx->l_stats[0]+=strlen(tmp);
+        continue;
+
+      }
+      if (expression[1]=='\'' && expression[2] && expression[3]=='\'')
+      {
+        char tmp[64];
+        sprintf(tmp,"%u",((unsigned char *)expression)[2]);
+        expression+=4;
+
+        memcpy(buf+len,tmp,strlen(tmp));
+        len+=strlen(tmp);
+        ctx->l_stats[0]+=strlen(tmp);
+        continue;
+      }
+      if (toupper(expression[1]) == 'P' && toupper(expression[2]) == 'I')
+      {
+        static char *str="3.141592653589793";
+        expression+=3;
+        memcpy(buf+len,str,17);
+        len+=17; //strlen(str);
+        ctx->l_stats[0]+=17;
+	      continue;
+      }
+      if (toupper(expression[1]) == 'E')
+      {
+        static char *str="2.71828183";
+        expression+=2;
+        memcpy(buf+len,str,10);
+        len+=10; //strlen(str);
+        ctx->l_stats[0]+=10;
+  	    continue;
+      }
+      if (toupper(expression[1]) == 'P' && toupper(expression[2]) == 'H' && toupper(expression[3]) == 'I')
+      {
+        static char *str="1.61803399";
+        expression+=4;
+        memcpy(buf+len,str,10);
+        len+=10; //strlen(str);
+        ctx->l_stats[0]+=10;
+	      continue;
+      }
+      
+    }
+
+    {
+      char c=*expression++;
+
+      if (c == '\n') onCompileNewLine(ctx,expression-expression_start,len);
+      if (isspace(c)) c=' ';
+
+      if (c == '(') semicnt++;
+      else if (c == ')') { semicnt--; if (semicnt < 0) semicnt=0; }
+      else if (c == ';' && semicnt > 0)
+      {
+        // convert ; to % if next nonwhitespace char is alnum, otherwise convert to space
+        int p=0;
+        int nc;
+		int commentstate=0;
+        	while ((nc=expression[p]))
+		{
+			if (!commentstate && nc == '/')
+			{
+				if (expression[p+1] == '/') commentstate=1;
+				else if (expression[p+1] == '*') commentstate=2;
+			}
+
+			if (commentstate == 1 && nc == '\n') commentstate=0;
+			else if (commentstate == 2 && nc == '*' && expression[p+1]=='/')
+			{
+				p++; // skip *
+				commentstate=0;
+			}
+			else if (!commentstate && !isspace(nc)) break;
+
+			p++;
+		}
+		// fucko, we should look for even more chars, me thinks
+        if (nc && (isalnum(nc) 
+#if 1
+				|| nc == '(' || nc == '_' || nc == '!' || nc == '$' 
+#endif
+				)) c='%';
+        else c = ' '; // stray ;
+      }
+#if 0
+      else if (semicnt > 0 && c == ',')
+      {
+        int p=0;
+        int nc;
+        while ((nc=expression[p]) && isspace(nc)) p++;
+		if (nc == ',' || nc == ')') 
+		{
+			expression += p+1;
+			buf[len++]=',';
+			buf[len++]='0';
+			c=nc; // append this char
+		}
+      }
+#endif
+	  // list of operators
+
+	  else if (!isspace(c) && !isalnum(c)) // check to see if this operator is ours
+	  {
+
+			static char *symbollists[]=
+			{
+				"", // or any control char that is not parenthed
+				":(,;?%", 
+				",):?;", // or || or &&
+				",);", // jf> removed :? from this, for =
+				",);",
+        "",  // only scans for a negative ] level
+
+			};
+
+
+			static struct 
+			{
+			  char op[2];
+			  char lscan,rscan;
+			  char *func;
+			} preprocSymbols[] = 
+			{
+				{{'+','='}, 0, 3, "_addop" },
+				{{'-','='}, 0, 3, "_subop" },
+				{{'%','='}, 0, 3, "_modop" },
+				{{'|','='}, 0, 3, "_orop" },
+				{{'&','='}, 0, 3, "_andop"},
+
+				{{'/','='}, 0, 3, "_divop"},
+				{{'*','='}, 0, 3, "_mulop"},
+				{{'^','='}, 0, 3, "_powop"},
+
+				{{'=','='}, 1, 2, "_equal" },
+				{{'<','='}, 1, 2, "_beleq" },
+				{{'>','='}, 1, 2, "_aboeq" },
+				{{'<',0  }, 1, 2, "_below" },
+				{{'>',0  }, 1, 2, "_above" },
+				{{'!','='}, 1, 2, "_noteq" },
+				{{'|','|'}, 1, 2, "_or" },
+				{{'&','&'}, 1, 2, "_and" },
+				{{'=',0  }, 0, 3, "_set" },
+				{{'%',0},   0, 0, "_mod" },
+				{{'^',0},   0, 0, "pow" },
+
+
+        {{'[',0  }, 0, 5, },
+				{{'!',0  },-1, 0, }, // this should also ignore any leading +-
+				{{'?',0  }, 1, 4, },
+
+			};
+
+
+			int n;
+			int ns=sizeof(preprocSymbols)/sizeof(preprocSymbols[0]);
+			for (n = 0; n < ns; n++)
+			{
+				if (c == preprocSymbols[n].op[0] && (!preprocSymbols[n].op[1] || expression[0] == preprocSymbols[n].op[1])) 
+				{
+					break;
+				}
+			}
+			if (n < ns)
+			{
+
+				int lscan=preprocSymbols[n].lscan;
+				int rscan=preprocSymbols[n].rscan;
+
+	       		// parse left side of =, scanning back for an unparenthed nonwhitespace nonalphanumeric nonparenth?
+	       		// so megabuf(x+y)= would be fine, x=, but +x= would do +set(x,)
+       			char *l_ptr=0;
+				char *r_ptr=0;
+	       		if (lscan >= 0)
+				{
+					char *scan=symbollists[lscan];
+	       			int l_semicnt=0;
+					l_ptr=buf + len - 1;
+					while (l_ptr >= buf)
+					{
+						if (*l_ptr == ')') l_semicnt++;
+						else if (*l_ptr == '(')
+						{
+							l_semicnt--;
+							if (l_semicnt < 0) break;
+						}
+						else if (!l_semicnt) 
+						{
+							if (!*scan)
+							{
+								if (!isspace(*l_ptr) && !isalnum(*l_ptr) && *l_ptr != '_' && *l_ptr != '.') break;
+							}
+							else
+							{
+								char *sc=scan;
+								if (lscan == 2 && ( // not currently used, even
+									(l_ptr[0]=='|' && l_ptr[1] == '|')||
+									(l_ptr[0]=='&' && l_ptr[1] == '&')
+									)
+								   ) break;
+								while (*sc && *l_ptr != *sc) sc++;
+								if (*sc) break;
+							}
+						}
+						l_ptr--;
+					}
+					buf[len]=0;
+
+					l_ptr++;
+
+					len = l_ptr - buf;
+
+					l_ptr = strdup(l_ptr); // doesn't need to be preprocessed since it just was
+	       		}
+				if (preprocSymbols[n].op[1]) expression++;
+
+				r_ptr=expression;
+				{ 
+					// scan forward to an uncommented,  unparenthed semicolon, comma, or )
+					int r_semicnt=0;
+					int r_qcnt=0;
+					char *scan=symbollists[rscan];
+					int commentstate=0;
+					int hashadch=0;
+          int bracketcnt=0;
+					while (*r_ptr)
+					{
+						if (!commentstate && *r_ptr == '/')
+						{
+							if (r_ptr[1] == '/') commentstate=1;
+							else if (r_ptr[1] == '*') commentstate=2;
+						}
+						if (commentstate == 1 && *r_ptr == '\n') commentstate=0;
+						else if (commentstate == 2 && *r_ptr == '*' && r_ptr[1]=='/')
+						{
+							r_ptr++; // skip *
+							commentstate=0;
+						}
+						else if (!commentstate)
+						{
+							if (*r_ptr == '(') {hashadch=1; r_semicnt++; }
+							else if (*r_ptr == ')') 
+							{
+								r_semicnt--;
+								if (r_semicnt < 0) break;
+							}
+							else if (!r_semicnt)
+							{
+								char *sc=scan;
+								if (*r_ptr == ';' || *r_ptr == ',') break;
+							
+								if (!rscan)
+								{
+									if (*r_ptr == ':') break;
+									if (!isspace(*r_ptr) && !isalnum(*r_ptr) && *r_ptr != '_' && *r_ptr != '.' && hashadch) break;
+									if (isalnum(*r_ptr) || *r_ptr == '_')hashadch=1;
+								}								
+								else if (rscan == 2 &&
+									((r_ptr[0]=='|' && r_ptr[1] == '|')||
+									(r_ptr[0]=='&' && r_ptr[1] == '&')
+									)
+								   ) break;
+
+								else if (rscan == 3 || rscan == 4)
+								{
+									if (*r_ptr == ':') r_qcnt--;
+									else if (*r_ptr == '?') r_qcnt++;
+
+									if (r_qcnt < 3-rscan) break;
+								}
+                else if (rscan == 5)
+                {
+                  if (*r_ptr == '[') bracketcnt++;
+                  else if (*r_ptr == ']') bracketcnt--;
+                  if (bracketcnt < 0) break;
+                }
+
+								while (*sc && *r_ptr != *sc) sc++;
+								if (*sc) break;
+							}
+						}
+						r_ptr++;
+					}
+					// expression -> r_ptr is our string (not including r_ptr)
+
+					{
+						char *orp=r_ptr;
+
+						char rps=*orp;
+						*orp=0; // temporarily terminate
+
+						r_ptr=preprocessCode(ctx,expression);
+						expression=orp;
+
+						*orp = rps; // fix termination(restore string)
+					}
+
+				}
+
+				if (r_ptr)
+				{
+					int thisl = strlen(l_ptr?l_ptr:"") + strlen(r_ptr) + 32;
+
+	    			if (len+thisl > alloc_len-64)
+    				{
+      					alloc_len = len+thisl+128;
+      					buf=(char*)realloc(buf,alloc_len);
+    				}
+
+
+          if (n == ns-3)
+          {
+            char *lp = l_ptr;
+            char *rp = r_ptr;
+      	    while (lp && *lp && isspace(*lp)) lp++;
+      	    while (rp && *rp && isspace(*rp)) rp++;
+            if (lp && !strncasecmp(lp,"gmem",4) && (!lp[4] || isspace(lp[4])))
+            {
+              len+=sprintf(buf+len,"_gmem(%s",r_ptr && *r_ptr ? r_ptr : "0");
+              ctx->l_stats[0]+=strlen(l_ptr)+4;
+            }
+            else if (rp && *rp && strcmp(rp,"0"))
+            {
+  	      len+=sprintf(buf+len,"_mem((%s)+(%s)",lp,rp);
+              ctx->l_stats[0]+=strlen(lp)+strlen(rp)+8;
+            }
+            else 
+            {
+	      len+=sprintf(buf+len,"_mem(%s",lp);
+              ctx->l_stats[0]+=strlen(lp)+4;
+            }
+
+            // skip the ]
+            if (*expression == ']') expression++;
+
+          }
+					else if (n == ns-2)
+					{
+						len+=sprintf(buf+len,"_not(%s",
+							r_ptr);
+
+						ctx->l_stats[0]+=4;
+					}
+					else if (n == ns-1)// if (l_ptr,r_ptr1,r_ptr2)
+					{
+						char *rptr2=r_ptr;
+						char *tmp=r_ptr;
+						int parcnt=0;
+						int qcnt=1;
+						while (*rptr2)
+						{
+							if (*rptr2 == '?') qcnt++;
+							else if (*rptr2 == ':') qcnt--;
+							else if (*rptr2 == '(') parcnt++;
+							else if (*rptr2 == ')') parcnt--;
+							if (parcnt < 0) break;
+							if (!parcnt && !qcnt && *rptr2 == ':') break;
+							rptr2++;
+						}
+						if (*rptr2) *rptr2++=0;
+						while (isspace(*rptr2)) rptr2++;
+
+						while (isspace(*tmp)) tmp++;
+
+						len+=sprintf(buf+len,"_if(%s,%s,%s",l_ptr,*tmp?tmp:"0",*rptr2?rptr2:"0");
+						ctx->l_stats[0]+=6;
+					}
+					else
+					{
+						len+=sprintf(buf+len,"%s(%s,%s",preprocSymbols[n].func,l_ptr?l_ptr:"",r_ptr);
+						ctx->l_stats[0]+=strlen(preprocSymbols[n].func)+2;
+					}
+
+				}
+
+				free(r_ptr);
+				free(l_ptr);
+
+
+				c = ')'; // close parenth below
+		  }
+	  }
+
+//      if (c != ' ' || (len && buf[len-1] != ' ')) // don't bother adding multiple spaces
+      {
+      	buf[len++]=c;
+      	if (c != ' ') ctx->l_stats[0]++;
+      }
+    }
+  }
+  buf[len]=0;
+
+  return buf;
+}
+
+#ifdef PPROC_TEST
+
+int main(int argc, char* argv[])
+{
+	compileContext ctx={0};
+	char *p=preprocessCode(&ctx,argv[1]);
+	if (p)printf("%s\n",p);
+	free(p);
+	return 0;
+}
+
+#endif
+
+#if 0
+static void movestringover(char *str, int amount)
+{
+  char tmp[1024+8];
+
+  int l=(int)strlen(str);
+  l=min(1024-amount-1,l);
+
+  memcpy(tmp,str,l+1);
+
+  while (l >= 0 && tmp[l]!='\n') l--;
+  l++;
+
+  tmp[l]=0;//ensure we null terminate
+
+  memcpy(str+amount,tmp,l+1);
+}
+#endif
+
+//------------------------------------------------------------------------------
+NSEEL_CODEHANDLE NSEEL_code_compile(NSEEL_VMCTX _ctx, char *_expression, int lineoffs)
+{
+  compileContext *ctx = (compileContext *)_ctx;
+  char *expression,*expression_start;
+  int computable_size=0;
+  codeHandleType *handle;
+  startPtr *scode=NULL;
+  startPtr *startpts=NULL;
+
+  if (!ctx) return 0;
+
+  ctx->last_error_string[0]=0;
+
+  if (!_expression || !*_expression) return 0;
+
+  freeBlocks((llBlock **)&ctx->tmpblocks_head);  // free blocks
+  freeBlocks((llBlock **)&ctx->blocks_head);  // free blocks
+  memset(ctx->l_stats,0,sizeof(ctx->l_stats));
+  free(ctx->compileLineRecs); ctx->compileLineRecs=0; ctx->compileLineRecs_size=0; ctx->compileLineRecs_alloc=0;
+
+  handle = (codeHandleType*)newBlock(sizeof(codeHandleType),8);
+
+  if (!handle) 
+  {
+    return 0;
+  }
+  
+  memset(handle,0,sizeof(codeHandleType));
+
+  expression_start=expression=preprocessCode(ctx,_expression);
+
+
+  while (*expression)
+  {
+	void *startptr;
+    char *expr;
+    ctx->colCount=0;
+	ctx->computTableTop=0;
+
+    // single out segment
+    while (*expression == ';' || isspace(*expression)) expression++;
+    if (!*expression) break;
+    expr=expression;
+
+    while (*expression && *expression != ';') expression++;
+    if (*expression) *expression++ = 0;
+
+    // parse
+    
+    startptr=nseel_compileExpression(ctx,expr);
+
+    if (ctx->computTableTop > NSEEL_MAX_TEMPSPACE_ENTRIES- /* safety */ 16 - /* alignment */4 ||
+        !startptr) 
+    { 
+      int byteoffs = expr - expression_start;
+      int destoffs,linenumber;
+      char buf[21], *p;
+      int x,le;
+
+#ifdef NSEEL_EEL1_COMPAT_MODE
+      if (!startptr) continue;
+#endif
+      if (ctx->errVar > 0) byteoffs += ctx->errVar;
+      linenumber=findByteOffsetInSource(ctx,byteoffs,&destoffs);
+      if (destoffs < 0) destoffs=0;
+
+      le=strlen(_expression);
+      if (destoffs >= le) destoffs=le;
+      p= _expression + destoffs;
+      for (x = 0;x < 20; x ++)
+      {
+	      if (!*p || *p == '\r' || *p == '\n') break;
+	      buf[x]=*p++;
+      }
+      buf[x]=0;
+
+      sprintf(ctx->last_error_string,"Around line %d '%s'",linenumber+lineoffs,buf);
+
+      ctx->last_error_string[sizeof(ctx->last_error_string)-1]=0;
+      scode=NULL; 
+      break; 
+    }
+    if (computable_size < ctx->computTableTop)
+    {
+      computable_size=ctx->computTableTop;
+    }
+
+    {
+      startPtr *tmp=(startPtr*) __newBlock((llBlock **)&ctx->tmpblocks_head,sizeof(startPtr));
+      if (!tmp) break;
+
+      tmp->startptr = startptr;
+    tmp->next=NULL;
+    if (!scode) scode=startpts=tmp;
+    else
+    {
+      scode->next=tmp;
+      scode=tmp;
+    }
+  }
+}
+  free(ctx->compileLineRecs); ctx->compileLineRecs=0; ctx->compileLineRecs_size=0; ctx->compileLineRecs_alloc=0;
+
+  // check to see if failed on the first startingCode
+  if (!scode)
+  {
+    handle=NULL;              // return NULL (after resetting blocks_head)
+  }
+  else 
+  {
+    char *tabptr = (char *)(handle->workTable=calloc(computable_size+64,  sizeof(EEL_F)));
+    unsigned char *writeptr;
+    startPtr *p=startpts;
+    int size=sizeof(GLUE_RET)+GLUE_FUNC_ENTER_SIZE+GLUE_FUNC_LEAVE_SIZE; // for ret at end :)
+
+    if (((INT_PTR)tabptr)&31)
+      tabptr += 32-(((INT_PTR)tabptr)&31);
+
+    // now we build one big code segment out of our list of them, inserting a mov esi, computable before each item
+    while (p)
+    {
+      size += GLUE_RESET_ESI(NULL,0);
+      size+=*(int *)p->startptr;
+      p=p->next;
+    }
+    handle->code = newBlock(size,32);
+    if (handle->code)
+    {
+      writeptr=(unsigned char *)handle->code;
+      memcpy(writeptr,&GLUE_FUNC_ENTER,GLUE_FUNC_ENTER_SIZE); writeptr += GLUE_FUNC_ENTER_SIZE;
+      p=startpts;
+      while (p)
+      {
+        int thissize=*(int *)p->startptr;
+        writeptr+=GLUE_RESET_ESI(writeptr,tabptr);
+        //memcpy(writeptr,&GLUE_MOV_ESI_EDI,sizeof(GLUE_MOV_ESI_EDI));
+        //writeptr+=sizeof(GLUE_MOV_ESI_EDI);
+        memcpy(writeptr,(char*)p->startptr + 4,thissize);
+        writeptr += thissize;
+      
+        p=p->next;
+      }
+      memcpy(writeptr,&GLUE_FUNC_LEAVE,GLUE_FUNC_LEAVE_SIZE); writeptr += GLUE_FUNC_LEAVE_SIZE;
+      memcpy(writeptr,&GLUE_RET,sizeof(GLUE_RET)); writeptr += sizeof(GLUE_RET);
+      ctx->l_stats[1]=size;
+    }
+    handle->blocks = ctx->blocks_head;
+    ctx->blocks_head=0;
+
+  }
+  freeBlocks((llBlock **)&ctx->tmpblocks_head);  // free blocks
+  freeBlocks((llBlock **)&ctx->blocks_head);  // free blocks
+
+  if (handle)
+  {
+    memcpy(handle->code_stats,ctx->l_stats,sizeof(ctx->l_stats));
+    nseel_evallib_stats[0]+=ctx->l_stats[0];
+    nseel_evallib_stats[1]+=ctx->l_stats[1];
+    nseel_evallib_stats[2]+=ctx->l_stats[2];
+    nseel_evallib_stats[3]+=ctx->l_stats[3];
+    nseel_evallib_stats[4]++;
+  }
+  memset(ctx->l_stats,0,sizeof(ctx->l_stats));
+
+  free(expression_start);
+
+  return (NSEEL_CODEHANDLE)handle;
+}
+
+//------------------------------------------------------------------------------
+void NSEEL_code_execute(NSEEL_CODEHANDLE code)
+{
+  INT_PTR tabptr;
+  INT_PTR codeptr;
+  codeHandleType *h = (codeHandleType *)code;
+  if (!h || !h->code) return;
+
+  codeptr = (INT_PTR) h->code;
+#if 0
+  {
+	unsigned int *p=(unsigned int *)codeptr;
+	while (*p != GLUE_RET[0])
+	{
+		printf("instr:%04X:%04X\n",*p>>16,*p&0xffff);
+		p++;
+	}
+  }
+#endif
+
+  tabptr=(INT_PTR)h->workTable;
+  if (tabptr&31)
+    tabptr += 32-((tabptr)&31);
+  //printf("calling code!\n");
+  GLUE_CALL_CODE(tabptr,codeptr);
+
+}
+
+
+char *NSEEL_code_getcodeerror(NSEEL_VMCTX ctx)
+{
+  compileContext *c=(compileContext *)ctx;
+  if (ctx && c->last_error_string[0]) return c->last_error_string;
+  return 0;
+}
+
+//------------------------------------------------------------------------------
+void NSEEL_code_free(NSEEL_CODEHANDLE code)
+{
+  codeHandleType *h = (codeHandleType *)code;
+  if (h != NULL)
+  {
+    free(h->workTable);
+    nseel_evallib_stats[0]-=h->code_stats[0];
+    nseel_evallib_stats[1]-=h->code_stats[1];
+    nseel_evallib_stats[2]-=h->code_stats[2];
+    nseel_evallib_stats[3]-=h->code_stats[3];
+    nseel_evallib_stats[4]--;
+    freeBlocks(&h->blocks);
+
+
+  }
+
+}
+
+
+//------------------------------------------------------------------------------
+void NSEEL_VM_resetvars(NSEEL_VMCTX _ctx)
+{
+  if (_ctx)
+  {
+    compileContext *ctx=(compileContext *)_ctx;
+    int x;
+    if (ctx->varTable_Names || ctx->varTable_Values) for (x = 0; x < ctx->varTable_numBlocks; x ++)
+    {
+      if (ctx->varTable_Names) free(ctx->varTable_Names[x]);
+      if (ctx->varTable_Values) free(ctx->varTable_Values[x]);
+    }
+
+    free(ctx->varTable_Values);
+    free(ctx->varTable_Names);
+    ctx->varTable_Values=0;
+    ctx->varTable_Names=0;
+
+    ctx->varTable_numBlocks=0;
+  }
+}
+
+
+NSEEL_VMCTX NSEEL_VM_alloc() // return a handle
+{
+  compileContext *ctx=calloc(1,sizeof(compileContext));
+  return ctx;
+}
+
+void NSEEL_VM_free(NSEEL_VMCTX _ctx) // free when done with a VM and ALL of its code have been freed, as well
+{
+
+  if (_ctx)
+  {
+    compileContext *ctx=(compileContext *)_ctx;
+    NSEEL_VM_resetvars(_ctx);
+    NSEEL_VM_freeRAM(_ctx);
+
+    freeBlocks((llBlock **)&ctx->tmpblocks_head);  // free blocks
+    freeBlocks((llBlock **)&ctx->blocks_head);  // free blocks
+    free(ctx->compileLineRecs);
+    free(ctx);
+  }
+
+}
+
+int *NSEEL_code_getstats(NSEEL_CODEHANDLE code)
+{
+  codeHandleType *h = (codeHandleType *)code;
+  if (h)
+  {
+    return h->code_stats;
+  }
+  return 0;
+}
+
+void NSEEL_VM_SetCustomFuncThis(NSEEL_VMCTX ctx, void *thisptr)
+{
+  if (ctx)
+  {
+    compileContext *c=(compileContext*)ctx;
+    c->caller_this=thisptr;
+  }
+}
+
+
+
+
+
+void NSEEL_PProc_RAM(void *data, int data_size, compileContext *ctx)
+{
+  if (data_size>0) EEL_GLUE_set_immediate(data, &ctx->ram_blocks); 
+}
+void NSEEL_PProc_THIS(void *data, int data_size, compileContext *ctx)
+{
+  if (data_size>0) EEL_GLUE_set_immediate(data, ctx->caller_this);
+}
diff --git a/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-eval.c b/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-eval.c
new file mode 100644
index 00000000..2dc1d063
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-eval.c
@@ -0,0 +1,321 @@
+/*
+  Expression Evaluator Library (NS-EEL) v2
+  Copyright (C) 2004-2008 Cockos Incorporated
+  Copyright (C) 1999-2003 Nullsoft, Inc.
+  
+  nseel-eval.c
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include <string.h>
+#include <ctype.h>
+#include "ns-eel-int.h"
+
+#define NSEEL_VARS_MALLOC_CHUNKSIZE 8
+#define NSEEL_GLOBALVAR_BASE (1<<24)
+
+#ifndef NSEEL_MAX_VARIABLE_NAMELEN
+#define NSEEL_MAX_VARIABLE_NAMELEN 8
+#endif
+
+#define strnicmp(x,y,z) strncasecmp(x,y,z)
+
+
+#define INTCONST 1
+#define DBLCONST 2
+#define HEXCONST 3
+#define VARIABLE 4
+#define OTHER    5
+
+EEL_F nseel_globalregs[100];
+
+
+//------------------------------------------------------------------------------
+void *nseel_compileExpression(compileContext *ctx, char *exp)
+{
+  ctx->errVar=0;
+  nseel_llinit(ctx);
+  if (!nseel_yyparse(ctx,exp) && !ctx->errVar)
+  {
+    return (void*)ctx->result;
+  }
+  return 0;
+}
+
+//------------------------------------------------------------------------------
+void nseel_setLastVar(compileContext *ctx)
+{
+  nseel_gettoken(ctx,ctx->lastVar, sizeof(ctx->lastVar));
+}
+
+void NSEEL_VM_enumallvars(NSEEL_VMCTX ctx, int (*func)(const char *name, EEL_F *val, void *ctx), void *userctx)
+{
+  compileContext *tctx = (compileContext *) ctx;
+  int wb;
+  if (!tctx) return;
+
+  for (wb = 0; wb < tctx->varTable_numBlocks; wb ++)
+  {
+    int ti;
+    int namepos=0;
+    for (ti = 0; ti < NSEEL_VARS_PER_BLOCK; ti ++)
+    {        
+      char *p=tctx->varTable_Names[wb]+namepos;
+      if (!*p) break;
+
+
+      if (!func(p,&tctx->varTable_Values[wb][ti],userctx)) 
+        break;
+
+      namepos += NSEEL_MAX_VARIABLE_NAMELEN;
+    }
+    if (ti < NSEEL_VARS_PER_BLOCK)
+      break;
+  }
+}
+
+
+
+static INT_PTR register_var(compileContext *ctx, const char *name, EEL_F **ptr)
+{
+  int wb;
+  int ti=0;
+  int i=0;
+  char *nameptr;
+  for (wb = 0; wb < ctx->varTable_numBlocks; wb ++)
+  {
+    int namepos=0;
+    for (ti = 0; ti < NSEEL_VARS_PER_BLOCK; ti ++)
+    {        
+      if (!ctx->varTable_Names[wb][namepos] || !strnicmp(ctx->varTable_Names[wb]+namepos,name,NSEEL_MAX_VARIABLE_NAMELEN))
+      {
+        break;
+      }
+      namepos += NSEEL_MAX_VARIABLE_NAMELEN;
+      i++;
+    }
+    if (ti < NSEEL_VARS_PER_BLOCK)
+      break;
+  }
+  if (wb == ctx->varTable_numBlocks)
+  {
+    ti=0;
+    // add new block
+    if (!(ctx->varTable_numBlocks&(NSEEL_VARS_MALLOC_CHUNKSIZE-1)) || !ctx->varTable_Values || !ctx->varTable_Names )
+    {
+      ctx->varTable_Values = (EEL_F **)realloc(ctx->varTable_Values,(ctx->varTable_numBlocks+NSEEL_VARS_MALLOC_CHUNKSIZE) * sizeof(EEL_F *));
+      ctx->varTable_Names = (char **)realloc(ctx->varTable_Names,(ctx->varTable_numBlocks+NSEEL_VARS_MALLOC_CHUNKSIZE) * sizeof(char *));
+    }
+    ctx->varTable_numBlocks++;
+
+    ctx->varTable_Values[wb] = (EEL_F *)calloc(sizeof(EEL_F),NSEEL_VARS_PER_BLOCK);
+    ctx->varTable_Names[wb] = (char *)calloc(NSEEL_MAX_VARIABLE_NAMELEN,NSEEL_VARS_PER_BLOCK);
+  }
+
+  nameptr=ctx->varTable_Names[wb]+ti*NSEEL_MAX_VARIABLE_NAMELEN;
+  if (!nameptr[0])
+  {
+    strncpy(nameptr,name,NSEEL_MAX_VARIABLE_NAMELEN);
+  }
+  if (ptr) *ptr = ctx->varTable_Values[wb] + ti;
+  return i;
+}
+
+//------------------------------------------------------------------------------
+INT_PTR nseel_setVar(compileContext *ctx, INT_PTR varNum)
+{
+  if (varNum < 0) // adding new var
+  {
+    char *var=ctx->lastVar;
+    if (!strnicmp(var,"reg",3) && strlen(var) == 5 && isdigit(var[3]) && isdigit(var[4]))
+    {
+      int i,x=atoi(var+3);
+      if (x < 0 || x > 99) x=0;
+      i=NSEEL_GLOBALVAR_BASE+x;
+      return i;
+    }
+
+    return register_var(ctx,ctx->lastVar,NULL);
+
+  }
+
+  // setting/getting oldvar
+
+  if (varNum >= NSEEL_GLOBALVAR_BASE && varNum < NSEEL_GLOBALVAR_BASE+100)
+  {
+    return varNum;
+  }
+
+  {
+    int wb,ti;
+    char *nameptr;
+    if (varNum < 0 || varNum >= ctx->varTable_numBlocks*NSEEL_VARS_PER_BLOCK) return -1;
+
+    wb=varNum/NSEEL_VARS_PER_BLOCK;
+    ti=(varNum%NSEEL_VARS_PER_BLOCK);
+    nameptr=ctx->varTable_Names[wb]+ti*NSEEL_MAX_VARIABLE_NAMELEN;
+    if (!nameptr[0]) 
+    {
+      strncpy(nameptr,ctx->lastVar,NSEEL_MAX_VARIABLE_NAMELEN);
+    }  
+    return varNum;  
+  }
+
+}
+
+//------------------------------------------------------------------------------
+INT_PTR nseel_getVar(compileContext *ctx, INT_PTR i)
+{
+  if (i >= 0 && i < (NSEEL_VARS_PER_BLOCK*ctx->varTable_numBlocks))
+    return nseel_createCompiledValue(ctx,0, ctx->varTable_Values[i/NSEEL_VARS_PER_BLOCK] + i%NSEEL_VARS_PER_BLOCK); 
+  if (i >= NSEEL_GLOBALVAR_BASE && i < NSEEL_GLOBALVAR_BASE+100) 
+    return nseel_createCompiledValue(ctx,0, nseel_globalregs+i-NSEEL_GLOBALVAR_BASE);
+
+  return nseel_createCompiledValue(ctx,0, NULL);
+}
+
+
+
+//------------------------------------------------------------------------------
+EEL_F *NSEEL_VM_regvar(NSEEL_VMCTX _ctx, const char *var)
+{
+  compileContext *ctx = (compileContext *)_ctx;
+  EEL_F *r;
+  if (!ctx) return 0;
+
+  if (!strnicmp(var,"reg",3) && strlen(var) == 5 && isdigit(var[3]) && isdigit(var[4]))
+  {
+    int x=atoi(var+3);
+    if (x < 0 || x > 99) x=0;
+    return nseel_globalregs + x;
+  }
+
+  register_var(ctx,var,&r);
+
+  return r;
+}
+
+//------------------------------------------------------------------------------
+INT_PTR nseel_translate(compileContext *ctx, int type)
+{
+	int v;
+	int n;
+	*ctx->yytext = 0;
+	nseel_gettoken(ctx,ctx->yytext, sizeof(ctx->yytext));
+
+	switch (type)
+	{
+	case INTCONST: return nseel_createCompiledValue(ctx,(EEL_F)atoi(ctx->yytext), NULL);
+	case DBLCONST: return nseel_createCompiledValue(ctx,(EEL_F)atof(ctx->yytext), NULL);
+	case HEXCONST:
+		v=0;
+		n=0;
+		while (1)
+		{
+			int a=ctx->yytext[n++];
+			if (a >= '0' && a <= '9') v=(v<<4)+a-'0';
+			else if (a >= 'A' && a <= 'F') v=(v<<4)+10+a-'A';
+			else if (a >= 'a' && a <= 'f') v=(v<<4)+10+a-'a';
+			else break;
+		}
+		return nseel_createCompiledValue(ctx,(EEL_F)v, NULL);
+	}
+	return 0;
+}
+
+//------------------------------------------------------------------------------
+INT_PTR nseel_lookup(compileContext *ctx, int *typeOfObject)
+{
+	int i, ti, wb;
+	const char *nptr;
+	nseel_gettoken(ctx,ctx->yytext, sizeof(ctx->yytext));
+
+	if (!strnicmp(ctx->yytext,"reg",3) && strlen(ctx->yytext) == 5 && isdigit(ctx->yytext[3]) && isdigit(ctx->yytext[4]) && (i=atoi(ctx->yytext+3))>=0 && i<100)
+	{
+		*typeOfObject=IDENTIFIER;
+		return i+NSEEL_GLOBALVAR_BASE;
+	}
+
+	i=0;
+	for (wb = 0; wb < ctx->varTable_numBlocks; wb ++)
+	{
+		int namepos=0;
+		for (ti = 0; ti < NSEEL_VARS_PER_BLOCK; ti ++)
+		{        
+			if (!ctx->varTable_Names[wb][namepos]) break;
+
+			if (!strnicmp(ctx->varTable_Names[wb]+namepos,ctx->yytext,NSEEL_MAX_VARIABLE_NAMELEN))
+			{
+				*typeOfObject = IDENTIFIER;
+				return i;
+			}
+
+			namepos += NSEEL_MAX_VARIABLE_NAMELEN;
+			i++;
+		}
+		if (ti < NSEEL_VARS_PER_BLOCK) break;
+	}
+
+
+	nptr = ctx->yytext;
+	if (!strcasecmp(nptr,"if")) nptr="_if";
+	else if (!strcasecmp(nptr,"bnot")) nptr="_not";
+	else if (!strcasecmp(nptr,"assign")) nptr="_set";
+	else if (!strcasecmp(nptr,"equal")) nptr="_equal";
+	else if (!strcasecmp(nptr,"below")) nptr="_below";
+	else if (!strcasecmp(nptr,"above")) nptr="_above";
+	else if (!strcasecmp(nptr,"megabuf")) nptr="_mem";
+	else if (!strcasecmp(nptr,"gmegabuf")) nptr="_gmem";
+	else if (!strcasecmp(nptr,"int")) nptr="floor";
+
+	for (i=0;nseel_getFunctionFromTable(i);i++)
+	{
+		functionType *f=nseel_getFunctionFromTable(i);
+		if (!strcasecmp(f->name, nptr))
+		{
+			switch (f->nParams)
+			{
+			case 1: *typeOfObject = FUNCTION1; break;
+			case 2: *typeOfObject = FUNCTION2; break;
+			case 3: *typeOfObject = FUNCTION3; break;
+			default: *typeOfObject = IDENTIFIER; break;
+			}
+			return i;
+		}
+	}
+
+	*typeOfObject = IDENTIFIER;
+	nseel_setLastVar(ctx);
+	return nseel_setVar(ctx,-1);
+}
+
+
+
+//---------------------------------------------------------------------------
+void nseel_count(compileContext *ctx)
+{
+  nseel_gettoken(ctx,ctx->yytext, sizeof(ctx->yytext));
+  ctx->colCount+=strlen(ctx->yytext);
+}
+
+//---------------------------------------------------------------------------
+int nseel_yyerror(compileContext *ctx)
+{
+  ctx->errVar = ctx->colCount;
+  return 0;
+}
diff --git a/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-lextab.c b/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-lextab.c
new file mode 100644
index 00000000..9d90b769
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-lextab.c
@@ -0,0 +1,277 @@
+/*
+  Expression Evaluator Library (NS-EEL) v2
+  Copyright (C) 2004-2008 Cockos Incorporated
+  Copyright (C) 1999-2003 Nullsoft, Inc.
+  
+  nseel-lextab.c
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "ns-eel-int.h"
+
+
+#define LEXSKIP		(-1)
+
+static int _lmovb(struct lextab *lp, int c, int st)
+{
+        int base;
+
+        while ((base = lp->llbase[st]+c) > lp->llnxtmax ||
+                        (lp->llcheck[base] & 0377) != st) {
+
+                if (st != lp->llendst) {
+                        base = lp->lldefault[st] & 0377;
+                        st = base;
+                }
+                else
+                        return(-1);
+        }
+        return(lp->llnext[base]&0377);
+}
+
+#define INTCONST 1
+#define DBLCONST 2
+#define HEXCONST 3
+#define VARIABLE 4
+#define OTHER    5
+
+static int _Alextab(compileContext *ctx, int __na__)		 
+{
+	// fucko: JF> 17 -> 19?
+  
+   if (__na__ >= 0 && __na__ <= 17) 
+	   nseel_count(ctx);
+   switch (__na__)
+   {
+      case 0:           
+        *ctx->yytext = 0;
+        nseel_gettoken(ctx,ctx->yytext, sizeof(ctx->yytext));
+        if (ctx->yytext[0] < '0' || ctx->yytext[0] > '9') // not really a hex value, lame
+        {
+          nseel_setLastVar(ctx); ctx->yylval = nseel_lookup(ctx,&__na__); return __na__;
+        }
+        ctx->yylval = nseel_translate(ctx,HEXCONST); 
+      return VALUE;
+      case 1:   ctx->yylval = nseel_translate(ctx,INTCONST); return VALUE; 
+      case 2:   ctx->yylval = nseel_translate(ctx,INTCONST); return VALUE; 
+      case 3:   ctx->yylval = nseel_translate(ctx,DBLCONST); return VALUE; 
+      case 4:
+      case 5:   nseel_setLastVar(ctx); ctx->yylval = nseel_lookup(ctx,&__na__); return __na__;
+      case 6:   return '+';
+      case 7:   return '-';
+      case 8:   return '*'; 
+      case 9:   return '/'; 
+      case 10:  return '%'; 
+      case 11:  return '&'; 
+      case 12:  return '|'; 
+      case 13:  return '('; 
+      case 14:  return ')'; 
+      case 15:  return '='; 
+      case 16:  return ','; 
+      case 17:  return ';'; 
+	}
+	return (LEXSKIP);
+}
+
+
+static char _Flextab[] =
+   {
+   1, 18, 17, 16, 15, 14, 13, 12,
+   11, 10, 9, 8, 7, 6, 4, 5,
+   5, 4, 4, 3, 3, 3, 3, 4,
+   0, 4, 5, 0, 5, 4, 1, 3,
+   0, 2, -1, 1, -1,
+   };
+
+
+static char _Nlextab[] =
+   {
+   36, 36, 36, 36, 36, 36, 36, 36,
+   36, 1, 36, 36, 36, 36, 36, 36,
+   36, 36, 36, 36, 36, 36, 36, 36,
+   36, 36, 36, 36, 36, 36, 36, 36,
+   1, 36, 36, 36, 36, 9, 8, 36,
+   6, 5, 11, 13, 3, 12, 19, 10,
+   30, 30, 30, 30, 30, 30, 30, 30,
+   30, 30, 36, 2, 36, 4, 36, 36,
+   36, 29, 29, 29, 29, 29, 29, 18,
+   18, 18, 18, 18, 18, 18, 18, 18,
+   18, 18, 18, 18, 18, 18, 18, 18,
+   18, 18, 18, 36, 36, 36, 36, 18,
+   36, 29, 29, 29, 29, 29, 23, 18,
+   18, 18, 18, 18, 18, 18, 18, 18,
+   18, 18, 18, 18, 18, 18, 14, 18,
+   18, 18, 18, 36, 7, 15, 15, 15,
+   15, 15, 15, 15, 15, 15, 15, 36,
+   36, 36, 36, 36, 36, 36, 17, 17,
+   17, 17, 17, 17, 17, 17, 17, 17,
+   17, 17, 17, 17, 17, 17, 17, 17,
+   17, 17, 17, 17, 17, 17, 17, 17,
+   36, 36, 36, 36, 17, 36, 17, 17,
+   17, 17, 17, 17, 17, 17, 17, 17,
+   17, 17, 17, 17, 17, 17, 17, 17,
+   17, 17, 17, 17, 17, 17, 17, 17,
+   15, 15, 15, 15, 15, 15, 15, 15,
+   15, 15, 36, 36, 36, 36, 36, 36,
+   36, 16, 16, 16, 16, 16, 16, 16,
+   16, 16, 16, 16, 16, 16, 16, 16,
+   16, 16, 16, 16, 16, 16, 16, 16,
+   16, 16, 16, 36, 36, 36, 36, 16,
+   36, 16, 16, 16, 16, 16, 16, 16,
+   16, 16, 16, 16, 16, 16, 16, 16,
+   16, 16, 16, 16, 16, 16, 16, 16,
+   16, 16, 16, 22, 22, 22, 22, 22,
+   22, 22, 22, 22, 22, 21, 21, 21,
+   21, 21, 21, 21, 21, 21, 21, 36,
+   20, 26, 26, 26, 26, 26, 26, 26,
+   26, 26, 26, 36, 36, 36, 36, 36,
+   36, 36, 25, 25, 25, 25, 25, 25,
+   36, 24, 36, 36, 36, 36, 36, 36,
+   20, 36, 36, 36, 36, 36, 36, 36,
+   36, 36, 36, 36, 36, 36, 36, 36,
+   36, 36, 25, 25, 25, 25, 25, 25,
+   36, 24, 26, 26, 26, 26, 26, 26,
+   26, 26, 26, 26, 36, 36, 36, 36,
+   36, 36, 36, 28, 28, 28, 28, 28,
+   28, 36, 27, 36, 36, 36, 36, 36,
+   36, 36, 36, 36, 36, 36, 36, 36,
+   36, 36, 36, 36, 36, 36, 36, 36,
+   36, 36, 36, 28, 28, 28, 28, 28,
+   28, 31, 27, 35, 35, 35, 35, 35,
+   35, 35, 35, 35, 35, 36, 36, 36,
+   36, 36, 36, 36, 34, 34, 34, 33,
+   34, 34, 36, 32, 36, 36, 36, 36,
+   36, 36, 36, 36, 36, 36, 36, 36,
+   36, 36, 36, 36, 36, 36, 36, 36,
+   36, 36, 36, 36, 34, 34, 34, 33,
+   34, 34, 36, 32, 34, 34, 34, 34,
+   34, 34, 34, 34, 34, 34, 36, 36,
+   36, 36, 36, 36, 36, 34, 34, 34,
+   34, 34, 34, 36, 32, 36, 36, 36,
+   36, 36, 36, 36, 36, 36, 36, 36,
+   36, 36, 36, 36, 36, 36, 36, 36,
+   36, 36, 36, 36, 36, 34, 34, 34,
+   34, 34, 34, 36, 32,
+   };
+
+static char _Clextab[] =
+   {
+   -1, -1, -1, -1, -1, -1, -1, -1,
+   -1, 0, -1, -1, -1, -1, -1, -1,
+   -1, -1, -1, -1, -1, -1, -1, -1,
+   -1, -1, -1, -1, -1, -1, -1, -1,
+   0, -1, -1, -1, -1, 0, 0, -1,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, -1, 0, -1, 0, -1, -1,
+   -1, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, -1, -1, -1, -1, 0,
+   -1, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, -1, 0, 14, 14, 14,
+   14, 14, 14, 14, 14, 14, 14, -1,
+   -1, -1, -1, -1, -1, -1, 14, 14,
+   14, 14, 14, 14, 14, 14, 14, 14,
+   14, 14, 14, 14, 14, 14, 14, 14,
+   14, 14, 14, 14, 14, 14, 14, 14,
+   -1, -1, -1, -1, 14, -1, 14, 14,
+   14, 14, 14, 14, 14, 14, 14, 14,
+   14, 14, 14, 14, 14, 14, 14, 14,
+   14, 14, 14, 14, 14, 14, 14, 14,
+   15, 15, 15, 15, 15, 15, 15, 15,
+   15, 15, -1, -1, -1, -1, -1, -1,
+   -1, 15, 15, 15, 15, 15, 15, 15,
+   15, 15, 15, 15, 15, 15, 15, 15,
+   15, 15, 15, 15, 15, 15, 15, 15,
+   15, 15, 15, -1, -1, -1, -1, 15,
+   -1, 15, 15, 15, 15, 15, 15, 15,
+   15, 15, 15, 15, 15, 15, 15, 15,
+   15, 15, 15, 15, 15, 15, 15, 15,
+   15, 15, 15, 19, 19, 19, 19, 19,
+   19, 19, 19, 19, 19, 20, 20, 20,
+   20, 20, 20, 20, 20, 20, 20, -1,
+   19, 23, 23, 23, 23, 23, 23, 23,
+   23, 23, 23, -1, -1, -1, -1, -1,
+   -1, -1, 23, 23, 23, 23, 23, 23,
+   -1, 23, -1, -1, -1, -1, -1, -1,
+   19, -1, -1, -1, -1, -1, -1, -1,
+   -1, -1, -1, -1, -1, -1, -1, -1,
+   -1, -1, 23, 23, 23, 23, 23, 23,
+   -1, 23, 26, 26, 26, 26, 26, 26,
+   26, 26, 26, 26, -1, -1, -1, -1,
+   -1, -1, -1, 26, 26, 26, 26, 26,
+   26, -1, 26, -1, -1, -1, -1, -1,
+   -1, -1, -1, -1, -1, -1, -1, -1,
+   -1, -1, -1, -1, -1, -1, -1, -1,
+   -1, -1, -1, 26, 26, 26, 26, 26,
+   26, 30, 26, 30, 30, 30, 30, 30,
+   30, 30, 30, 30, 30, -1, -1, -1,
+   -1, -1, -1, -1, 30, 30, 30, 30,
+   30, 30, -1, 30, -1, -1, -1, -1,
+   -1, -1, -1, -1, -1, -1, -1, -1,
+   -1, -1, -1, -1, -1, -1, -1, -1,
+   -1, -1, -1, -1, 30, 30, 30, 30,
+   30, 30, -1, 30, 33, 33, 33, 33,
+   33, 33, 33, 33, 33, 33, -1, -1,
+   -1, -1, -1, -1, -1, 33, 33, 33,
+   33, 33, 33, -1, 33, -1, -1, -1,
+   -1, -1, -1, -1, -1, -1, -1, -1,
+   -1, -1, -1, -1, -1, -1, -1, -1,
+   -1, -1, -1, -1, -1, 33, 33, 33,
+   33, 33, 33, -1, 33,
+   };
+
+static char _Dlextab[] =
+   {
+   36, 36, 36, 36, 36, 36, 36, 36,
+   36, 36, 36, 36, 36, 36, 36, 36,
+   15, 14, 14, 36, 36, 20, 19, 14,
+   14, 23, 15, 15, 26, 23, 36, 19,
+   36, 36, 33, 30,
+   };
+
+static int _Blextab[] =
+   {
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 77, 152,
+   0, 0, 0, 227, 237, 0, 0, 249,
+   0, 0, 306, 0, 0, 0, 363, 0,
+   0, 420, 0, 0, 0,
+   };
+
+struct lextab nseel_lextab =	{
+			36,		 
+			_Dlextab,	 
+			_Nlextab,	 
+			_Clextab,	 
+			_Blextab,	 
+			524,		 
+			_lmovb,		 
+			_Flextab,	 
+			_Alextab,	 
+
+			0,   	 
+			0,		 
+			0,		 
+			0,		 
+			};
+
+ 
diff --git a/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-ram.c b/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-ram.c
new file mode 100644
index 00000000..d20dd449
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-ram.c
@@ -0,0 +1,320 @@
+/*
+  Expression Evaluator Library (NS-EEL) v2
+  Copyright (C) 2004-2008 Cockos Incorporated
+  Copyright (C) 1999-2003 Nullsoft, Inc.
+  
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "ns-eel.h"
+#include "ns-eel-int.h"
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+
+#ifdef _WIN32
+#include <malloc.h>
+#endif
+
+unsigned int NSEEL_RAM_limitmem=0;
+unsigned int NSEEL_RAM_memused=0;
+int NSEEL_RAM_memused_errors=0;
+
+
+
+int NSEEL_VM_wantfreeRAM(NSEEL_VMCTX ctx)
+{
+	if (ctx)
+  {
+    compileContext *c=(compileContext*)ctx;
+    if (c->ram_needfree) 
+      return 1;
+  }
+  return 0;
+}
+
+void NSEEL_VM_freeRAMIfCodeRequested(NSEEL_VMCTX ctx) // check to see if our free flag was set
+{
+	if (ctx)
+	{
+  	compileContext *c=(compileContext*)ctx;
+  	if (c->ram_needfree) 
+		{
+      NSEEL_HOSTSTUB_EnterMutex();
+			if (c->ram_blocks)
+			{
+				INT_PTR startpos=((INT_PTR)c->ram_needfree)-1;
+	 			EEL_F **blocks = (EEL_F **)c->ram_blocks;
+				INT_PTR pos=0;
+				int x;
+  			for (x = 0; x < NSEEL_RAM_BLOCKS; x ++)
+  			{
+					if (pos >= startpos)
+					{
+						if (blocks[x])
+						{
+							if (NSEEL_RAM_memused >= sizeof(EEL_F) * NSEEL_RAM_ITEMSPERBLOCK) 
+								NSEEL_RAM_memused -= sizeof(EEL_F) * NSEEL_RAM_ITEMSPERBLOCK;
+							else NSEEL_RAM_memused_errors++;
+						}
+       	 		free(blocks[x]);
+       	 		blocks[x]=0;
+					}
+					pos+=NSEEL_RAM_ITEMSPERBLOCK;
+ 				}
+ 				if (!startpos) 
+				{
+					free(blocks);
+ 					c->ram_blocks=0;
+				}
+			}
+			c->ram_needfree=0;
+      NSEEL_HOSTSTUB_LeaveMutex();
+		}
+
+	}
+}
+
+
+EEL_F * NSEEL_CGEN_CALL __NSEEL_RAMAllocGMEM(EEL_F ***blocks, int w)
+{
+  static EEL_F * volatile  gmembuf;
+  if (blocks) return __NSEEL_RAMAlloc(blocks,w);
+
+  if (!gmembuf)
+  {
+    NSEEL_HOSTSTUB_EnterMutex(); 
+    if (!gmembuf) gmembuf=(EEL_F*)calloc(sizeof(EEL_F),NSEEL_SHARED_GRAM_SIZE);
+    NSEEL_HOSTSTUB_LeaveMutex();
+
+    if (!gmembuf) return 0;
+  }
+
+  return gmembuf+(((unsigned int)w)&((NSEEL_SHARED_GRAM_SIZE)-1));
+}
+
+EEL_F * NSEEL_CGEN_CALL  __NSEEL_RAMAlloc(EEL_F ***blocks, int w)
+{
+  int whichblock;
+  EEL_F **pblocks=*blocks;
+
+  int is_locked=0;
+
+  if (!pblocks)
+  {
+    if (!is_locked) { is_locked=1; NSEEL_HOSTSTUB_EnterMutex(); }
+
+    if (!(pblocks=*blocks))
+    {
+      pblocks = *blocks = (EEL_F **)calloc(sizeof(EEL_F *),NSEEL_RAM_BLOCKS);
+      if (!pblocks) {
+        if (is_locked) NSEEL_HOSTSTUB_LeaveMutex();
+        return 0;
+      }
+    }
+  }
+
+//  fprintf(stderr,"got request at %d, %d\n",w/NSEEL_RAM_ITEMSPERBLOCK, w&(NSEEL_RAM_ITEMSPERBLOCK-1));
+  if (w >= 0 && (whichblock = w/NSEEL_RAM_ITEMSPERBLOCK) < NSEEL_RAM_BLOCKS)
+  {
+    EEL_F *p=pblocks[whichblock];
+    if (!p)
+    {
+      if (!is_locked) { is_locked=1; NSEEL_HOSTSTUB_EnterMutex(); }
+
+      if (!(p=pblocks[whichblock]))
+      {
+
+      	const int msize=sizeof(EEL_F) * NSEEL_RAM_ITEMSPERBLOCK;
+      	if (!NSEEL_RAM_limitmem || NSEEL_RAM_memused+msize < NSEEL_RAM_limitmem) 
+      	{
+	      	p=pblocks[whichblock]=(EEL_F *)calloc(sizeof(EEL_F),NSEEL_RAM_ITEMSPERBLOCK);
+      		if (p) NSEEL_RAM_memused+=msize;
+      	}
+        if (!p) w=0;
+      }
+    }	  
+    if (is_locked) NSEEL_HOSTSTUB_LeaveMutex();
+    return p + (w&(NSEEL_RAM_ITEMSPERBLOCK-1));
+  }
+  if (is_locked) NSEEL_HOSTSTUB_LeaveMutex();
+//  fprintf(stderr,"ret 0\n");
+  return 0;
+}
+
+
+EEL_F * NSEEL_CGEN_CALL __NSEEL_RAM_MemFree(EEL_F ***blocks, EEL_F *which)
+{
+	int d=EEL_F2int(*which);
+	if (d < 0) d=0;
+	if (d < NSEEL_RAM_BLOCKS*NSEEL_RAM_ITEMSPERBLOCK) ((INT_PTR *)blocks)[1]=1+d;
+	return which;
+}
+
+
+
+
+
+
+EEL_F * NSEEL_CGEN_CALL __NSEEL_RAM_MemCpy(EEL_F ***blocks,EEL_F *dest, EEL_F *src, EEL_F *lenptr)
+{
+	int dest_offs = EEL_F2int(*dest + 0.0001);
+	int src_offs = EEL_F2int(*src + 0.0001);
+  int len = EEL_F2int(*lenptr + 0.0001);
+
+  // trim to front
+  if (src_offs<0)
+  {
+    len += src_offs;
+    dest_offs -= src_offs;
+    src_offs=0;
+  }
+  if (dest_offs<0)
+  {
+    len += dest_offs;
+    src_offs -= dest_offs;
+    dest_offs=0;
+  }
+
+  while (len > 0)
+  {
+    EEL_F *srcptr,*destptr;
+    int copy_len = len;
+    int maxdlen=NSEEL_RAM_ITEMSPERBLOCK - (dest_offs&(NSEEL_RAM_ITEMSPERBLOCK-1));
+    int maxslen=NSEEL_RAM_ITEMSPERBLOCK -  (src_offs&(NSEEL_RAM_ITEMSPERBLOCK-1));
+
+    if (dest_offs >= NSEEL_RAM_BLOCKS*NSEEL_RAM_ITEMSPERBLOCK || 
+        src_offs >= NSEEL_RAM_BLOCKS*NSEEL_RAM_ITEMSPERBLOCK) break;
+
+    if (copy_len > maxdlen) copy_len=maxdlen;
+    if (copy_len > maxslen) copy_len=maxslen;
+
+    if (copy_len<1) break;
+
+    srcptr = __NSEEL_RAMAlloc(blocks,src_offs);
+    destptr = __NSEEL_RAMAlloc(blocks,dest_offs);
+    if (!srcptr || !destptr) break;
+
+    memmove(destptr,srcptr,sizeof(EEL_F)*copy_len);
+    src_offs+=copy_len;
+    dest_offs+=copy_len;
+    len-=copy_len;
+  }
+  return dest;
+}
+
+EEL_F * NSEEL_CGEN_CALL __NSEEL_RAM_MemSet(EEL_F ***blocks,EEL_F *dest, EEL_F *v, EEL_F *lenptr)
+{  
+	int offs = EEL_F2int(*dest + 0.0001);
+  int len = EEL_F2int(*lenptr + 0.0001);
+  EEL_F t;
+  if (offs<0) 
+  {
+    len += offs;
+    offs=0;
+  }
+  if (offs >= NSEEL_RAM_BLOCKS*NSEEL_RAM_ITEMSPERBLOCK) return dest;
+
+  if (offs+len > NSEEL_RAM_BLOCKS*NSEEL_RAM_ITEMSPERBLOCK) len = NSEEL_RAM_BLOCKS*NSEEL_RAM_ITEMSPERBLOCK - offs;
+
+  if (len < 1) return dest;
+  
+
+  t=*v; // set value
+
+//  int lastBlock=-1;
+  while (len > 0)
+  {
+    int lcnt;
+    EEL_F *ptr=__NSEEL_RAMAlloc(blocks,offs);
+    if (!ptr) break;
+
+    lcnt=NSEEL_RAM_ITEMSPERBLOCK-(offs&(NSEEL_RAM_ITEMSPERBLOCK-1));
+    if (lcnt > len) lcnt=len;
+
+    len -= lcnt;
+    offs += lcnt;
+
+    while (lcnt--)
+    {
+      *ptr++=t;
+    }       
+  }
+  return dest;
+}
+
+
+void NSEEL_VM_SetGRAM(NSEEL_VMCTX ctx, void **gram)
+{
+  if (ctx)
+  {
+    compileContext *c=(compileContext*)ctx;
+    c->gram_blocks = gram;
+  }
+}
+
+
+void NSEEL_VM_freeRAM(NSEEL_VMCTX ctx)
+{
+  if (ctx)
+  {
+    int x;
+    compileContext *c=(compileContext*)ctx;
+    if (c->ram_blocks)
+    {
+      EEL_F **blocks = (EEL_F **)c->ram_blocks;
+      for (x = 0; x < NSEEL_RAM_BLOCKS; x ++)
+      {
+	      if (blocks[x])
+	      {
+		      if (NSEEL_RAM_memused >= sizeof(EEL_F) * NSEEL_RAM_ITEMSPERBLOCK) 
+			      NSEEL_RAM_memused -= sizeof(EEL_F) * NSEEL_RAM_ITEMSPERBLOCK;
+		      else NSEEL_RAM_memused_errors++;
+	      }
+        free(blocks[x]);
+        blocks[x]=0;
+      }
+      free(blocks);
+      c->ram_blocks=0;
+    }
+    c->ram_needfree=0; // no need to free anymore
+  }
+}
+
+void NSEEL_VM_FreeGRAM(void **ufd)
+{
+  if (ufd[0])
+  {
+    EEL_F **blocks = (EEL_F **)ufd[0];
+    int x;
+    for (x = 0; x < NSEEL_RAM_BLOCKS; x ++)
+    {
+	    if (blocks[x])
+	    {
+		    if (NSEEL_RAM_memused >= sizeof(EEL_F) * NSEEL_RAM_ITEMSPERBLOCK) 
+			  NSEEL_RAM_memused -= sizeof(EEL_F) * NSEEL_RAM_ITEMSPERBLOCK;
+		    else NSEEL_RAM_memused_errors++;
+	    }
+      free(blocks[x]);
+      blocks[x]=0;
+    }
+    free(blocks);
+    ufd[0]=0;
+  }
+}
\ No newline at end of file
diff --git a/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-yylex.c b/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-yylex.c
new file mode 100644
index 00000000..605b4776
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_milk2/ns-eel2/nseel-yylex.c
@@ -0,0 +1,163 @@
+/*
+  Expression Evaluator Library (NS-EEL)
+  Copyright (C) 2004-2008 Cockos Incorporated
+  Copyright (C) 1999-2003 Nullsoft, Inc.
+  
+  nseel-yylex.c
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#include "ns-eel-int.h"
+
+
+#define NBPW		 16
+#define EOF			(-1)
+
+
+#define YYERRORVAL   256     /* yacc's value */
+
+static int llset(compileContext *ctx);
+static int llinp(compileContext *ctx, char **exp);
+static int lexgetc(char **exp)
+{
+  char c= **exp;
+  if (c) (*exp)++;
+  return( c != 0 ? c : -1);
+}
+static int tst__b(register int c, char tab[])
+{
+  return (tab[(c >> 3) & 037] & (1 << (c & 07)) );
+}
+
+int nseel_gettoken(compileContext *ctx, char *lltb, int lltbsiz)
+{
+        register char *lp, *tp, *ep;
+
+        tp = lltb;
+        ep = tp+lltbsiz-1;
+        for (lp = ctx->llbuf; lp < ctx->llend && tp < ep;)
+                *tp++ = *lp++;
+        *tp = 0;
+        return(tp-lltb);
+}
+
+
+int nseel_yylex(compileContext *ctx, char **exp)
+{
+  register int c, st;
+  int final, l, llk, i;
+  register struct lextab *lp;
+  char *cp;
+
+  while (1)
+  {
+    llk = 0;
+    if (llset(ctx)) return(0);
+    st = 0;
+    final = -1;
+    lp = &nseel_lextab;
+
+    do {
+            if (lp->lllook && (l = lp->lllook[st])) {
+                    for (c=0; c<NBPW; c++)
+                            if (l&(1<<c))
+                                    ctx->llsave[c] = ctx->llp1;
+                    llk++;
+            }
+            if ((i = lp->llfinal[st]) != -1) {
+                    final = i;
+                    ctx->llend = ctx->llp1;
+            }
+            if ((c = llinp(ctx,exp)) < 0)
+                    break;
+            if ((cp = lp->llbrk) && llk==0 && tst__b(c, cp)) {
+                    ctx->llp1--;
+                    break;
+            }
+    } while ((st = (*lp->llmove)(lp, c, st)) != -1);
+
+
+    if (ctx->llp2 < ctx->llp1)
+            ctx->llp2 = ctx->llp1;
+    if (final == -1) {
+            ctx->llend = ctx->llp1;
+            if (st == 0 && c < 0)
+                    return(0);
+            if ((cp = lp->llill) && tst__b(c, cp)) {
+                    continue;
+            }
+            return(YYERRORVAL);
+    }
+    if ((c = (final >> 11) & 037))
+            ctx->llend = ctx->llsave[c-1];
+    if ((c = (*lp->llactr)(ctx,final&03777)) >= 0)
+            return(c);
+  }
+}
+
+void nseel_llinit(compileContext *ctx)
+{
+   ctx->llp1 = ctx->llp2 = ctx->llend = ctx->llbuf;
+   ctx->llebuf = ctx->llbuf + sizeof(ctx->llbuf);
+   ctx->lleof = ctx->yyline = 0;
+}
+
+
+static int llinp(compileContext *ctx, char **exp)
+{
+        register int c;
+        register struct lextab *lp;
+        register char *cp;
+
+        lp = &nseel_lextab;
+        cp = lp->llign;                         /* Ignore class         */
+        for (;;) {
+                /*
+                 * Get the next character from the save buffer (if possible)
+                 * If the save buffer's empty, then return EOF or the next
+                 * input character.  Ignore the character if it's in the
+                 * ignore class.
+                 */
+                c = (ctx->llp1 < ctx->llp2) ? *ctx->llp1 & 0377 : (ctx->lleof) ? EOF : lexgetc(exp);
+                if (c >= 0) {                   /* Got a character?     */
+                        if (cp && tst__b(c, cp))
+                                continue;       /* Ignore it            */
+                        if (ctx->llp1 >= ctx->llebuf) {   /* No, is there room?   */
+                                return -1;
+                        }
+                        *ctx->llp1++ = c;            /* Store in token buff  */
+                } else
+                        ctx->lleof = 1;              /* Set EOF signal       */
+                return(c);
+        }
+}
+
+static int llset(compileContext *ctx)
+/*
+ * Return TRUE if EOF and nothing was moved in the look-ahead buffer
+ */
+{
+        register char *lp1, *lp2;
+
+        for (lp1 = ctx->llbuf, lp2 = ctx->llend; lp2 < ctx->llp2;)
+                *lp1++ = *lp2++;
+        ctx->llend = ctx->llp1 = ctx->llbuf;
+        ctx->llp2 = lp1;
+        return(ctx->lleof && lp1 == ctx->llbuf);
+}