reorganized

svn path=/trunk/; revision=9400

98 files changed, 15191 insertions, 0 deletions

diff --git a/desiredata/extra/Makefile.am b/desiredata/extra/Makefile.am
new file mode 100644
index 00000000..913a378c
--- /dev/null
+++ b/desiredata/extra/Makefile.am
@@ -0,0 +1,26 @@
+#
+# automake template
+# added by tim blechmann
+#
+
+EXTRA_DIST = bonk~ choice expr~ fiddle~ loop~ lrshift~ pique 
+
+MAINTAINERCLEANFILES = Makefile.in \
+	Makefile 
+
+EXTERNS = ./*/*.$(EXT)
+
+all:
+	cd ./bonk~ && make @EXT@
+	cd ./choice && make @EXT@
+	cd ./expr~ && make @EXT@
+	cd ./fiddle~ && make @EXT@
+	cd ./loop~ && make @EXT@
+	cd ./lrshift~ && make @EXT@
+	cd ./pique && make @EXT@
+
+install:
+	install -m 644 $(EXTERNS) $(prefix)/lib/pd/extra
+
+dist-hook:
+	rm -rf `find $(distdir) -name CVS`	
\ No newline at end of file
diff --git a/desiredata/extra/README.txt b/desiredata/extra/README.txt
new file mode 100644
index 00000000..850e3032
--- /dev/null
+++ b/desiredata/extra/README.txt
@@ -0,0 +1,30 @@
+This is the README file for the "extras" library, consisting of Pd
+objects which are too specialized or otherwise non-canonical for
+inclusion into Pd proper.   These files are open source; see 
+LICENSE.txt in this distribution for details.
+Note however that "expr" is GPL (the rest is all BSD).
+
+This package should run in Pd under linux, MSW, or Mac OSX.
+You can additionally compile fiddle~. bonk~, and paf~ for Max/MSP.
+
+contents:
+
+externs:
+fiddle~ -- pitch tracker
+bonk~ - percussion detector
+choose - find the "best fit" of incoming vector with stored profiles
+paf~ -- phase aligned formant generator
+loop~ -- sample looper
+expr -- arithmetic expression evaluation (Shahrokh Yadegari)
+pique - fft-based peak finder
+lrshift~ - left or right shift an audio vector
+
+abstractions:
+hilbert~ - Hilbert transform for SSB modulation
+complex-mod~ - ring modulation for complex (real+imaginary) audio signals
+rev1~, etc. - reverberators
+
+These objects are part of the regular Pd distribution as of Pd version
+0.30.  Macintosh versions of fiddle~, bonk~, and paf~ are available
+from http://www.crca.ucsd.edu/~tapel
+- msp@ucsd.edu
diff --git a/desiredata/extra/bonk~/bonk~.c b/desiredata/extra/bonk~/bonk~.c
new file mode 100644
index 00000000..f97ae0e7
--- /dev/null
+++ b/desiredata/extra/bonk~/bonk~.c
@@ -0,0 +1,1077 @@
+/*  Copyright 1997-1999 Miller Puckette (msp@ucsd.edu) and Ted Apel
+(tapel@ucsd.edu). Permission is granted to use this software for any
+noncommercial purpose. For commercial licensing please contact the UCSD
+Technology Transfer Office.
+
+THE AUTHORS AND THEIR EMPLOYERS MAKE NO WARRANTY, EXPRESS OR IMPLIED,
+IN CONNECTION WITH THIS SOFTWARE!
+*/
+
+#include <math.h>
+#include <stdio.h>
+
+#ifdef NT
+#pragma warning (disable: 4305 4244)
+#endif
+
+#ifdef MSP
+
+#include "ext.h"
+#include "z_dsp.h"
+#include "math.h"
+#include "ext_support.h"
+#include "ext_proto.h"
+
+typedef double t_floatarg;      /* from m_pd.h */
+#define flog log
+#define fexp exp
+#define fsqrt sqrt
+#define t_resizebytes(a, b, c) t_resizebytes((char *)(a), (b), (c))
+
+#define flog log
+#define fexp exp
+#define fsqrt sqrt
+
+#define FILE_DIALOG 1   /* use dialogs to get file name */
+#define FILE_NAMED 2    /* symbol specifies file name */
+
+#define DUMTAB1SIZE 256
+#define DUMTAB2SIZE 1024
+
+static float rsqrt_exptab[DUMTAB1SIZE], rsqrt_mantissatab[DUMTAB2SIZE];
+
+void *bonk_class;
+#define getbytes t_getbytes
+#define freebytes t_freebytes
+#endif /* MSP */
+
+#ifdef PD
+#include "m_pd.h"
+static t_class *bonk_class;
+#endif
+
+/* ------------------------ bonk~ ----------------------------- */
+
+#define NPOINTS 256
+#define MAXCHANNELS 8
+#define DEFPERIOD 128
+#define DEFHITHRESH 60
+#define DEFLOTHRESH 50
+#define DEFMASKTIME 4
+#define DEFMASKDECAY 0.7
+#define DEFDEBOUNCEDECAY 0
+#define DEFMINVEL 7
+
+
+
+typedef struct _filterkernel
+{
+    int k_npoints;
+    float k_freq;
+    float k_normalize;
+    float *k_stuff;
+} t_filterkernel;
+
+#if 0   /* this is the design for 1.0: */
+static t_filterkernel bonk_filterkernels[] =
+    {{256, 2, .01562}, {256, 4, .01562}, {256, 6, .01562}, {180, 6, .02222},
+    {128, 6, .01803}, {90, 6, .02222}, {64, 6, .02362}, {46, 6, .02773},
+    {32, 6, .03227}, {22, 6, .03932}, {16, 6, .04489}};
+#endif
+
+    /* here's the 1.1 rev: */
+static t_filterkernel bonk_filterkernels[] =
+    {{256, 1, .01562, 0}, {256, 3, .01562, 0}, {256, 5, .01562, 0},
+    {212, 6, .01886, 0}, {150, 6, .01885, 0}, {106, 6, .02179, 0},
+    {76, 6, .0236, 0}, {54, 6, .02634, 0}, {38, 6, .03047, 0},
+    {26, 6, .03667, 0}, {18, 6, .04458, 0}};
+
+#define NFILTERS ((int)(sizeof(bonk_filterkernels)/ \
+    sizeof(bonk_filterkernels[0])))
+
+static float bonk_hanningwindow[NPOINTS];
+
+typedef struct _hist
+{
+    float h_power;
+    float h_mask;
+    float h_before;
+    int h_countup;
+} t_hist;
+
+typedef struct template
+{
+    float t_amp[NFILTERS];
+} t_template;
+
+typedef struct _insig
+{
+    t_hist g_hist[NFILTERS];    /* history for each filter */
+#ifdef PD
+    t_outlet *g_outlet;         /* outlet for raw data */
+#endif
+#ifdef MSP
+    void *g_outlet;             /* outlet for raw data */
+#endif
+    float *g_inbuf;             /* buffered input samples */
+    t_float *g_invec;           /* new input samples */
+} t_insig;
+
+typedef struct _bonk
+{
+#ifdef PD
+    t_object x_obj;
+    t_outlet *x_cookedout;
+    t_clock *x_clock;
+#endif /* PD */
+#ifdef MSP
+    t_pxobject x_obj;
+    void *x_cookedout;
+    void *x_clock;
+    short x_vol;
+#endif /* MSP */
+
+    t_hist x_hist[NFILTERS];
+    t_template *x_template;
+    t_insig *x_insig;                   
+    int x_ninsig;
+    int x_ntemplate;
+    int x_infill;
+    int x_countdown;
+    int x_period;
+    int x_willattack;
+    int x_debug;
+    float x_hithresh;
+    float x_lothresh;
+    int x_masktime;
+    float x_maskdecay;
+    int x_learn;
+    double x_learndebounce;     /* debounce time for "learn" mode */
+    int x_learncount;           /* countup for "learn" mode */
+    float x_debouncedecay;
+    float x_minvel;             /* minimum velocity we output */
+    float x_debouncevel;
+} t_bonk;
+
+#ifdef MSP
+static void *bonk_new(int period, int bonk2);
+void bonk_tick(t_bonk *x);
+void bonk_doit(t_bonk *x);
+static t_int *bonk_perform(t_int *w);
+void bonk_dsp(t_bonk *x, t_signal **sp);
+void bonk_assist(t_bonk *x, void *b, long m, long a, char *s);
+void bonk_thresh(t_bonk *x, t_floatarg f1, t_floatarg f2);
+void bonk_mask(t_bonk *x, t_floatarg f1, t_floatarg f2);
+void bonk_debounce(t_bonk *x, t_floatarg f1);
+static void bonk_print(t_bonk *x, t_floatarg f);
+static void bonk_learn(t_bonk *x, t_floatarg f);
+void bonk_bang(t_bonk *x);
+void bonk_setupkernels(void);
+void bonk_free(t_bonk *x);
+void bonk_setup(void);
+void main();
+float qrsqrt(float f);
+static void bonk_write(t_bonk *x, t_symbol *s);
+static void bonk_read(t_bonk *x, t_symbol *s);
+
+double clock_getsystime();
+double clock_gettimesince(double prevsystime);
+static char *strcpy(char *s1, const char *s2);
+static int ilog2(int n);
+#endif
+
+static void bonk_tick(t_bonk *x);
+
+static void bonk_donew(t_bonk *x, int period, int nsig)
+{
+    int i, j;
+    t_hist *h;
+    float *fp;
+    t_insig *g;
+    
+    for (j = 0, g = x->x_insig; j < nsig; j++, g++)
+    {
+        for (i = 0, h = g->g_hist; i--; h++)
+            h->h_power = h->h_mask = h->h_before = 0, h->h_countup = 0;
+                /* we ought to check for failure to allocate memory here */
+        g->g_inbuf = (float *)getbytes(NPOINTS * sizeof(float));
+        for (i = NPOINTS, fp = g->g_inbuf; i--; fp++) *fp = 0;
+    }
+    x->x_ninsig = nsig;
+    x->x_template = (t_template *)getbytes(0);
+    x->x_ntemplate = 0;
+    x->x_infill = 0;
+    x->x_countdown = 0;
+    if (!period) period = NPOINTS/2;
+    x->x_period = 1 << ilog2(period);
+    x->x_willattack = 0;
+    x->x_debug = 0;
+    x->x_hithresh = DEFHITHRESH;
+    x->x_lothresh = DEFLOTHRESH;
+    x->x_masktime = DEFMASKTIME;
+    x->x_maskdecay = DEFMASKDECAY;
+    x->x_learn = 0;
+    x->x_learndebounce = clock_getsystime();
+    x->x_learncount = 0;
+    x->x_debouncedecay = DEFDEBOUNCEDECAY;
+    x->x_minvel = DEFMINVEL;
+    x->x_debouncevel = 0;
+}
+
+
+static void bonk_print(t_bonk *x, t_floatarg f);
+
+static void bonk_dotick(t_bonk *x, int hit)
+{
+    t_atom at[NFILTERS], *ap, at2[3];
+    int i, j, k, n;
+    t_hist *h;
+    float powerout[NFILTERS*MAXCHANNELS], *pp, vel = 0, temperature = 0;
+    float *fp;
+    t_template *tp;
+    int nfit, ninsig = x->x_ninsig, ntemplate = x->x_ntemplate;
+    t_insig *gp;
+    int totalbins = NFILTERS * ninsig;
+    
+    x->x_willattack = 0;
+
+    for (i = ninsig, pp = powerout, gp = x->x_insig; i--; gp++)
+    {
+        for (j = 0, h = gp->g_hist; j < NFILTERS; j++, h++, pp++)
+        {
+            float power = (hit ? h->h_mask - h->h_before : h->h_power);
+            float intensity = *pp =
+                (power > 0 ? 100. * qrsqrt(qrsqrt(power)) : 0);
+            vel += intensity;
+            temperature += intensity * (float)j;
+        }
+    }
+    if (vel > 0) temperature /= vel;
+    else temperature = 0;
+    vel *= 0.5 / ninsig;        /* fudge factor */
+    if (hit)
+    {
+            /* if hit nonzero it's a clock callback.  if in "learn" mode update the
+            template list; in any event match the hit to known templates. */
+
+        if (vel < x->x_debouncevel)
+        {
+            if (x->x_debug)
+                post("bounce cancelled: vel %f debounce %f",
+                    vel, x->x_debouncevel);
+            return;
+        }
+        if (vel < x->x_minvel)
+        {
+            if (x->x_debug)
+                post("low velocity cancelled: vel %f, minvel %f",
+                    vel, x->x_minvel);
+            return;
+        }
+        x->x_debouncevel = vel;
+        if (x->x_learn)
+        {
+            double lasttime = x->x_learndebounce;
+            double msec = clock_gettimesince(lasttime);
+            if ((!ntemplate) || (msec > 200))
+            {
+                int countup = x->x_learncount;
+                    /* normalize to 100  */
+                float norm;
+                for (i = NFILTERS * ninsig, norm = 0, pp = powerout; i--; pp++)
+                    norm += *pp * *pp;
+                if (norm < 1.0e-15) norm = 1.0e-15;
+                norm = 100.f * qrsqrt(norm);
+                    /* check if this is the first strike for a new template */
+                if (!countup)
+                {
+                    int oldn = ntemplate;
+                    x->x_ntemplate = ntemplate = oldn + ninsig;
+                    x->x_template = (t_template *)t_resizebytes(x->x_template,
+                        oldn * sizeof(x->x_template[0]),
+                        ntemplate * sizeof(x->x_template[0]));
+                    for (i = ninsig, pp = powerout; i--; oldn++)
+                        for (j = NFILTERS, fp = x->x_template[oldn].t_amp; j--;
+                            pp++, fp++)
+                                *fp = *pp * norm;
+                }
+                else
+                {
+                    int oldn = ntemplate - ninsig;
+                    if (oldn < 0) post("bonk_tick bug");
+                    for (i = ninsig, pp = powerout; i--; oldn++)
+                    {
+                        for (j = NFILTERS, fp = x->x_template[oldn].t_amp; j--;
+                            pp++, fp++)
+                                *fp = (countup * *fp + *pp * norm)
+                                    /(countup + 1.0f);
+                    }
+                }
+                countup++;
+                if (countup == x->x_learn) countup = 0;
+                x->x_learncount = countup;
+            }
+            else return;
+        }
+        x->x_learndebounce = clock_getsystime();
+        if (ntemplate)
+        {
+            float bestfit = -1e30;
+            int templatecount;
+            nfit = -1;
+            for (i = 0, templatecount = 0, tp = x->x_template; 
+                templatecount < ntemplate; i++)
+            {
+                float dotprod = 0;
+                for (k = 0, pp = powerout;
+                    k < ninsig && templatecount < ntemplate;
+                        k++, tp++, templatecount++)
+                {
+                    for (j = NFILTERS, fp = tp->t_amp;
+                        j--; fp++, pp++)
+                    {
+                        if (*fp < 0 || *pp < 0) post("bonk_tick bug 2");
+                            dotprod += *fp * *pp;
+                    }
+                }
+                if (dotprod > bestfit)
+                {
+                    bestfit = dotprod;
+                    nfit = i;
+                }
+            }
+            if (nfit < 0) post("bonk_tick bug");
+        }
+        else nfit = 0;
+    }
+    else nfit = -1;     /* hit is zero; this is the "bang" method. */
+
+    if (x->x_debug)
+        post("bonk out: number %d, vel %f, temperature %f",
+            nfit, vel, temperature);
+    SETFLOAT(at2, nfit);
+    SETFLOAT(at2+1, vel);
+    SETFLOAT(at2+2, temperature);
+    outlet_list(x->x_cookedout, 0, 3, at2);
+
+    for (n = 0, gp = x->x_insig + (ninsig-1),
+        pp = powerout + NFILTERS * (ninsig-1);
+            n < ninsig; n++, gp--, pp -= NFILTERS)
+    {
+        float *pp2;
+        for (i = 0, ap = at, pp2 = pp; i < NFILTERS;
+            i++, ap++, pp2++)
+        {
+            ap->a_type = A_FLOAT;
+            ap->a_w.w_float = *pp2;
+        }
+        outlet_list(gp->g_outlet, 0, NFILTERS, at);
+    }
+}
+
+static void bonk_tick(t_bonk *x)
+{
+    bonk_dotick(x, 1);
+}
+
+static void bonk_doit(t_bonk *x)
+{
+    int i, j, n;
+    t_filterkernel *k;
+    t_hist *h;
+    float growth = 0, *fp1, *fp2, *fp3, *fp4;
+    float windowbuf[NPOINTS];
+    static int poodle;
+    int ninsig = x->x_ninsig;
+    t_insig *gp;
+    
+    for (n = 0, gp = x->x_insig; n < ninsig; n++, gp++)
+    {    
+        for (i = NPOINTS, fp1 = gp->g_inbuf, fp2 = bonk_hanningwindow,
+            fp3 = windowbuf; i--; fp1++, fp2++, fp3++)
+                *fp3 = *fp1 * *fp2;
+
+        for (i = 0, k = bonk_filterkernels, h = gp->g_hist;
+            i < NFILTERS; i++, k++, h++)
+        {
+            float power = 0, maskpow = h->h_mask;
+            int countup = h->h_countup;
+            int npoints = k->k_npoints;
+                /* special case: the fourth filter is centered */
+            float *inbuf = gp->g_inbuf +
+                (i == 3 ? ((NPOINTS - npoints) / 2) : 0);
+
+                /* run the filter repeatedly, sliding it forward by half its
+                length, stopping when it runs past the end of the buffer */
+            for (fp1 = inbuf, fp2 = fp1 + NPOINTS - k->k_npoints;
+                fp1 <= fp2; fp1 += npoints/2)
+            {
+                float rsum = 0, isum = 0;
+                for (fp3 = fp1, fp4 = k->k_stuff, j = npoints; j--;)
+                {
+                    float g = *fp3++;
+                    rsum += g * *fp4++;
+                    isum += g * *fp4++;
+                }
+                power += rsum * rsum + isum * isum;
+            }
+
+            if (!x->x_willattack) h->h_before = maskpow;
+
+            if (power > maskpow)
+                growth += power/(maskpow + 1.0e-15) - 1.f;
+            if (!x->x_willattack && countup >= x->x_masktime)
+                maskpow *= x->x_maskdecay;
+
+            if (power > maskpow)
+            {
+                maskpow = power;
+                countup = 0;
+            }
+            countup++;
+            h->h_countup = countup;
+            h->h_mask = maskpow;
+            h->h_power = power;
+        }
+    }
+    if (x->x_willattack > 4)
+    {
+            /* if it takes more than 4 analyses for the energy to stop growing,
+            forget it; we would rather miss the note than report it late. */
+        if (x->x_debug) post("soft attack cancelled");
+        x->x_willattack = 0;
+    }
+    else if (x->x_willattack)
+    {
+        if (growth < x->x_lothresh)
+            clock_delay(x->x_clock, 0);
+        else x->x_willattack++;
+    }
+    else if (growth > x->x_hithresh)
+    {
+        if (x->x_debug) post("attack; growth = %f", growth);
+        x->x_willattack = 1;
+        for (n = 0, gp = x->x_insig; n < ninsig; n++, gp++)
+            for (i = NFILTERS, h = gp->g_hist; i--; h++)
+                h->h_mask = h->h_power, h->h_countup = 0;
+    }
+    
+    x->x_debouncevel *= x->x_debouncedecay;
+    
+        /* shift the input buffer and update counters */
+    if (x->x_period > NPOINTS) x->x_countdown = x->x_period - NPOINTS;
+    else x->x_countdown = 0;
+    if (x->x_period < NPOINTS)
+    {
+        int overlap = NPOINTS - x->x_period;
+        
+        for (n = 0, gp = x->x_insig; n < ninsig; n++, gp++)
+            for (i = overlap, fp1 = gp->g_inbuf, fp2 = fp1 + x->x_period; i--;)
+                *fp1++ = *fp2++;
+        x->x_infill = overlap;
+    }
+    else x->x_infill = 0;
+    poodle = 1;
+}
+
+static t_int *bonk_perform(t_int *w)
+{
+    t_bonk *x = (t_bonk *)(w[1]);
+    int n = (int)(w[2]);
+    int onset = (int)(w[3]);
+    if (x->x_countdown > 0) x->x_countdown -= n;
+    else
+    {
+        int i, j, infill = x->x_infill, ninsig = x->x_ninsig;
+        t_insig *gp;
+        for (i = 0, gp = x->x_insig; i < ninsig; i++, gp++)
+        {
+            float *fp = gp->g_inbuf + infill;
+            t_float *in1 = gp->g_invec + onset;
+            for (j = 0; j < n; j++)
+                *fp++ = *in1++;
+        }
+        infill += n;
+        x->x_infill = infill;   
+        if (infill == NPOINTS) bonk_doit(x);
+    }
+    return (w+4);
+}
+
+static void bonk_dsp(t_bonk *x, t_signal **sp)
+{
+    int i, n = sp[0]->s_n, vsize = x->x_period, ninsig = x->x_ninsig;
+    t_insig *gp;
+    if (vsize > n) vsize = n;
+    
+    for (i = 0, gp = x->x_insig; i < ninsig; i++, gp++)
+        gp->g_invec = (*(sp++))->s_vec;
+
+    for (i = 0; i < n; i += vsize)
+        dsp_add(bonk_perform, 3, x, vsize, i);
+}
+
+static void bonk_thresh(t_bonk *x, t_floatarg f1, t_floatarg f2)
+{
+    if (f1 > f2)
+        post("bonk: warning: low threshold greater than hi threshold");
+    x->x_lothresh = f1;
+    x->x_hithresh = f2;
+}
+
+static void bonk_mask(t_bonk *x, t_floatarg f1, t_floatarg f2)
+{
+    int ticks = f1;
+    if (ticks < 0) ticks = 0;
+    if (f2 < 0) f2 = 0;
+    else if (f2 > 1) f2 = 1;
+    x->x_masktime = ticks;
+    x->x_maskdecay = f2;
+}
+
+static void bonk_debounce(t_bonk *x, t_floatarg f1)
+{
+    if (f1 < 0) f1 = 0;
+    else if (f1 > 1) f1 = 1;
+    x->x_debouncedecay = f1;
+}
+
+static void bonk_minvel(t_bonk *x, t_floatarg f)
+{
+    if (f < 0) f = 0; 
+    x->x_minvel = f;
+}
+
+static void bonk_print(t_bonk *x, t_floatarg f)
+{
+    int i;
+    post("thresh %f %f", x->x_lothresh, x->x_hithresh);
+    post("mask %d %f", x->x_masktime, x->x_maskdecay);
+    post("debounce %f", x->x_debouncedecay);
+    post("minvel %f", x->x_minvel);
+    if (x->x_ntemplate)
+    {
+        post("templates:");
+        for (i = 0; i < x->x_ntemplate; i++)
+            post("%2d \
+%5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f", i,
+            x->x_template[i].t_amp[0],
+            x->x_template[i].t_amp[1],
+            x->x_template[i].t_amp[2],
+            x->x_template[i].t_amp[3],
+            x->x_template[i].t_amp[4],
+            x->x_template[i].t_amp[5],
+            x->x_template[i].t_amp[6],
+            x->x_template[i].t_amp[7],
+            x->x_template[i].t_amp[8],
+            x->x_template[i].t_amp[9],
+            x->x_template[i].t_amp[10]);
+    }
+    else post("no templates");
+    if (x->x_learn) post("learn mode");
+    if (f != 0)
+    {
+        int j, ninsig = x->x_ninsig;
+        t_insig *gp;
+        for (j = 0, gp = x->x_insig; j < ninsig; j++, gp++)
+        {
+            t_hist *h;
+            if (ninsig > 1) post("input %d:", j+1);
+            for (i = NFILTERS, h = gp->g_hist; i--; h++)
+                post("pow %f mask %f before %f count %d",
+                    h->h_power, h->h_mask, h->h_before, h->h_countup);
+        }
+    }
+    if (x->x_debug) post("debug mode");
+}
+
+static void bonk_debug(t_bonk *x, t_floatarg f)
+{
+    x->x_debug = (f != 0);
+}
+
+static void bonk_learn(t_bonk *x, t_floatarg f)
+{
+    int n = f;
+    if (n < 0) n = 0;
+    if (n)
+    {
+        x->x_template = (t_template *)t_resizebytes(x->x_template,
+            x->x_ntemplate * sizeof(x->x_template[0]), 0);
+        x->x_ntemplate = 0;
+    }
+    x->x_learn = n;
+    x->x_learncount = 0;
+}
+
+static void bonk_forget(t_bonk *x)
+{
+    int ntemplate = x->x_ntemplate, newn = ntemplate - x->x_ninsig;
+    if (newn < 0) newn = 0;
+    x->x_template = (t_template *)t_resizebytes(x->x_template,
+        x->x_ntemplate * sizeof(x->x_template[0]),
+        newn * sizeof(x->x_template[0]));
+    x->x_ntemplate = newn;
+    x->x_learncount = 0;
+}
+
+#if 0
+static void bonk_bang(t_bonk *x)
+{
+    t_atom at[NFILTERS];
+    int i, j, ninsig = x->x_ninsig;
+    t_insig *gp;
+
+    SETFLOAT(at2, nfit);
+    SETFLOAT(at2+1, vel);
+    SETFLOAT(at2+2, temperature);
+    outlet_list(x->x_cookedout, 0L, 3, at2);
+    for (i = 0, gp = x->x_insig + (ninsig-1); i < ninsig; i++, gp--)
+    {
+        for (j = 0; j < NFILTERS; j++)
+        {
+            at[j].a_type = A_FLOAT;
+            at[j].a_w.w_float = 100 * qrsqrt(qrsqrt(gp->g_hist[j].h_power));
+        }
+        outlet_list(gp->g_outlet, 0L, NFILTERS, at);
+    }
+}
+#endif
+
+static void bonk_bang(t_bonk *x)
+{
+    bonk_dotick(x, 0);
+}
+
+static void bonk_setupkernels(void)
+{
+    int i, j;
+    float *fp;
+    for (i = 0; i < NFILTERS; i++)
+    {
+        int npoints = bonk_filterkernels[i].k_npoints;
+        float freq = bonk_filterkernels[i].k_freq;
+        float normalize = bonk_filterkernels[i].k_normalize;
+        float phaseinc = (2.f * 3.14159f) / npoints;
+        bonk_filterkernels[i].k_stuff =
+            (float *)getbytes(2 * sizeof(float) * npoints);
+        for (fp = bonk_filterkernels[i].k_stuff, j = npoints; j--;)
+        {
+            float phase = j * phaseinc;
+            float window = normalize * (0.5f - 0.5f * cos(phase));
+            *fp++ = window * cos(freq * phase);
+            *fp++ = window * sin(freq * phase);
+        }
+    }
+    for (i = 0; i < NPOINTS; i++)
+        bonk_hanningwindow[i] = (0.5f - 0.5f * cos(i * (2*3.14159)/NPOINTS));
+}
+
+#ifdef PD
+static void bonk_read(t_bonk *x, t_symbol *s)
+{
+    FILE *fd = fopen(s->s_name, "r");
+    float vec[NFILTERS];
+    int i, ntemplate = 0, remaining;
+    float *fp, *fp2;
+    if (!fd)
+    {
+        post("%s: open failed", s->s_name);
+        return;
+    }
+    x->x_template = (t_template *)t_resizebytes(x->x_template, 
+        x->x_ntemplate * sizeof(t_template), 0);
+    while (1)
+    {
+        for (i = NFILTERS, fp = vec; i--; fp++)
+            if (fscanf(fd, "%f", fp) < 1) goto nomore;
+        x->x_template = (t_template *)t_resizebytes(x->x_template,
+            ntemplate * sizeof(t_template),
+            (ntemplate + 1) * sizeof(t_template));
+        for (i = NFILTERS, fp = vec,
+            fp2 = x->x_template[ntemplate].t_amp; i--;)
+                *fp2++ = *fp++;
+        ntemplate++;
+    }
+nomore:
+    if (remaining = (ntemplate % x->x_ninsig))
+    {
+        post("bonk_read: %d templates not a multiple of %d; dropping extras");
+        x->x_template = (t_template *)t_resizebytes(x->x_template,
+            ntemplate * sizeof(t_template),
+                (ntemplate - remaining) * sizeof(t_template));
+        ntemplate = ntemplate - remaining;
+    }
+    post("bonk: read %d templates\n", ntemplate);
+    x->x_ntemplate = ntemplate;
+    fclose(fd);
+}
+#endif /* PD */
+
+#ifdef MSP
+static void bonk_read(t_bonk *x, t_symbol *s)
+{
+    SFTypeList types;
+    short vol = 0;
+    OSType type;
+    char name[256];
+    char **buf;
+    int eaten;
+    long size = 100;
+    int i, ntemplate = 0;
+    float vec[NFILTERS];
+    float *fp, *fp2;
+    if (s->s_name[0])
+    {
+        vol = defvolume();
+        strcpy (name, s->s_name);
+
+        if (readtohandle (name, vol, &buf, &size) != 0)
+
+        {
+            post("bonk~: problem with reading file.");
+            return;
+
+        }
+        else
+        {
+            post("bonk~: template read successfully.");
+        }
+        for (eaten = 0; ;)
+        {
+            for (i = NFILTERS, fp = vec; i--; fp++)
+            {
+                while (eaten < size && (
+                    (*buf)[eaten] == ' ' ||
+                    (*buf)[eaten] == '\t' ||
+                    (*buf)[eaten] == '\n' ||
+                    (*buf)[eaten] == ';'  ||
+                    (*buf)[eaten] == '\r'))
+                            eaten++;
+                if (eaten >= size) goto nomore;
+                if (sscanf(&(*buf)[eaten], "%f", fp) < 1) goto nomore;
+
+                while (eaten < size && !(
+                    (*buf)[eaten] == ' ' ||
+                    (*buf)[eaten] == '\t' ||
+                    (*buf)[eaten] == '\n' ||
+                    (*buf)[eaten] == ';'  ||
+                    (*buf)[eaten] == '\r'))
+                            eaten++;
+            }
+            x->x_template = (t_template *)t_resizebytes(x->x_template,
+
+            ntemplate * sizeof(t_template),
+            (ntemplate + 1) * sizeof(t_template));
+
+            for (i = NFILTERS, fp = vec, 
+                fp2 = x->x_template[ntemplate].t_amp; i--;)
+                    *fp2++ = *fp++;
+            ntemplate++;
+            post("bonk~: fp = %f", fp);
+        }
+    }
+    else
+    {
+        name[0] = 0;
+        types[0]='TEXT';
+        types[1]='maxb';
+
+        open_promptset("Select template for reading.");
+
+        if (open_dialog(name, &vol, &type, types, 2))
+        {
+            post("bonk~: open canceled");
+            return;
+        }
+        x->x_template = (t_template *)t_resizebytes(x->x_template,
+
+        x->x_ntemplate * sizeof(t_template), 0);
+
+
+        if (readtohandle (name, vol, &buf, &size) != 0)
+
+        {
+            post("bonk~: problem with reading file.");
+            return;
+
+        }
+        else
+        {
+            post("bonk~: template read successfully.");
+        }
+        for (eaten = 0; ;)
+        {
+            for (i = NFILTERS, fp = vec; i--; fp++)
+            {
+                while (eaten < size && (
+                    (*buf)[eaten] == ' ' ||
+                    (*buf)[eaten] == '\t' ||
+                    (*buf)[eaten] == '\n' ||
+                    (*buf)[eaten] == ';'  ||
+                    (*buf)[eaten] == '\r'))
+                            eaten++;
+                if (eaten >= size) goto nomore;
+                if (sscanf(&(*buf)[eaten], "%f", fp) < 1) goto nomore;
+
+                while (eaten < size && !(
+                    (*buf)[eaten] == ' ' ||
+                    (*buf)[eaten] == '\t' ||
+                    (*buf)[eaten] == '\n' ||
+                    (*buf)[eaten] == ';'  ||
+                    (*buf)[eaten] == '\r'))
+                            eaten++;
+            }
+            x->x_template = (t_template *)t_resizebytes(x->x_template,
+
+            ntemplate * sizeof(t_template),
+            (ntemplate + 1) * sizeof(t_template));
+
+            for (i = NFILTERS, fp = vec,
+                fp2 = x->x_template[ntemplate].t_amp; i--;)
+                    *fp2++ = *fp++;
+            ntemplate++;
+        }
+        nomore:
+        post("bonk~: read %d templates", ntemplate);
+
+        x->x_ntemplate = ntemplate;
+    }
+}
+#endif /* MSP */
+
+#ifdef PD
+static void bonk_write(t_bonk *x, t_symbol *s)
+{
+    FILE *fd = fopen(s->s_name, "w");
+    int i, ntemplate = x->x_ntemplate;
+    t_template *tp = x->x_template;
+    float *fp;
+    if (!fd)
+    {
+        post("%s: couldn't create", s->s_name);
+        return;
+    }
+    for (; ntemplate--; tp++)
+    {
+        for (i = NFILTERS, fp = tp->t_amp; i--; fp++)
+                fprintf(fd, "%6.2f ", *fp);
+        fprintf(fd, "\n");
+    }
+    post("bonk: wrote %d templates\n", x->x_ntemplate);
+    fclose(fd);
+}
+#endif /* PD */
+
+#ifdef MSP
+static void bonk_write(t_bonk *x, t_symbol *s)
+{
+
+    char fn[236];
+    short vol;
+    short bin = 0;
+    void* b;
+    int i, ntemplate = x->x_ntemplate;
+    t_template *tp = x->x_template;
+    if (s->s_name[0]) 
+    {
+        strcpy (fn, s->s_name);
+        vol = defvolume();
+        b = binbuf_new();
+        for (; ntemplate--; tp++)
+        {
+            int i;
+            Atom at[11];
+            for (i = 0; i < 11; i++)
+                at[i].a_type = A_FLOAT, at[i].a_w.w_float = tp->t_amp[i];
+            binbuf_insert(b, 0L, 11, at);
+        }
+        binbuf_write(b, fn, vol, bin);
+        freeobject(b);
+        post("bonk~: wrote file %s", fn);
+    }
+
+    else
+    {
+        saveas_promptset("Save Template file as");
+        strcpy(fn, "");
+        if (!saveas_dialog(fn, &vol, 0L))
+        {
+            b = binbuf_new();
+            for (; ntemplate--; tp++)
+            {
+                int i;
+                Atom at[11];
+                for (i = 0; i < 11; i++)
+                    at[i].a_type = A_FLOAT, at[i].a_w.w_float =
+                        tp->t_amp[i];
+                binbuf_insert(b, 0L, 11, at);
+            }
+            binbuf_write(b, fn, vol, bin);
+            freeobject(b);
+            post("bonk~: wrote file %s", fn);
+        }
+    } 
+}
+#endif /* MSP */
+
+static void bonk_free(t_bonk *x)
+{
+    int i, ninsig = x->x_ninsig;
+    t_insig *gp = x->x_insig;
+    for (i = 0, gp = x->x_insig; i < ninsig; i++, gp++)
+        freebytes(gp->g_inbuf, NPOINTS * sizeof(float));
+    clock_free(x->x_clock);
+}
+
+/* -------------------------- Pd glue ------------------------- */
+#ifdef PD
+
+static void *bonk_new(t_floatarg fperiod, t_floatarg fnsig)
+{
+    t_bonk *x = (t_bonk *)pd_new(bonk_class);
+    int nsig = fnsig, j;
+    t_insig *g;
+    if (nsig < 1) nsig = 1;
+    if (nsig > MAXCHANNELS) nsig = MAXCHANNELS;
+    
+    x->x_clock = clock_new(x, (t_method)bonk_tick);
+    x->x_insig = (t_insig *)getbytes(nsig * sizeof(*x->x_insig));
+    for (j = 0, g = x->x_insig; j < nsig; j++, g++)
+    {
+        g->g_outlet = outlet_new(&x->x_obj, gensym("list"));
+        if (j)
+            inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
+    }
+    x->x_cookedout = outlet_new(&x->x_obj, gensym("list"));
+    bonk_donew(x, fperiod, nsig);
+    return (x);
+}
+
+void bonk_tilde_setup(void)
+{
+    bonk_class = class_new(gensym("bonk~"), (t_newmethod)bonk_new, (t_method)bonk_free,
+        sizeof(t_bonk), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
+    class_addmethod(bonk_class, nullfn, gensym("signal"), 0);
+    class_addmethod(bonk_class, (t_method)bonk_dsp, gensym("dsp"), 0);
+    class_addbang(bonk_class, bonk_bang);
+    class_addmethod(bonk_class, (t_method)bonk_learn, gensym("learn"),
+        A_FLOAT, 0);
+    class_addmethod(bonk_class, (t_method)bonk_forget, gensym("forget"), 0);
+    class_addmethod(bonk_class, (t_method)bonk_thresh, gensym("thresh"),
+        A_FLOAT, A_FLOAT, 0);
+    class_addmethod(bonk_class, (t_method)bonk_mask, gensym("mask"),
+        A_FLOAT, A_FLOAT, 0);
+    class_addmethod(bonk_class, (t_method)bonk_debounce, gensym("debounce"),
+        A_FLOAT, 0);
+    class_addmethod(bonk_class, (t_method)bonk_minvel, gensym("minvel"),
+        A_FLOAT, 0);
+    class_addmethod(bonk_class, (t_method)bonk_print, gensym("print"),
+        A_DEFFLOAT, 0);
+    class_addmethod(bonk_class, (t_method)bonk_debug, gensym("debug"),
+        A_DEFFLOAT, 0);
+    class_addmethod(bonk_class, (t_method)bonk_read, gensym("read"),
+        A_SYMBOL, 0);
+    class_addmethod(bonk_class, (t_method)bonk_write, gensym("write"),
+        A_SYMBOL, 0);
+    bonk_setupkernels();
+    post("bonk version 1.1 TEST 3");
+}
+#endif
+
+/* -------------------------- MSP glue ------------------------- */
+#ifdef MSP
+
+static int ilog2(int n)
+{
+    int ret = -1;
+    while (n)
+    {
+        n >>= 1;
+        ret++;
+    }
+    return (ret);
+}
+
+static char *strcpy(char *s1, const char *s2)
+{
+    char *ret = s1;
+
+    while ((*s1++ = *s2++) != 0)
+        ;
+
+    return ret;
+}
+
+static void *bonk_new(int period, int nsig)
+{
+    int i, j;
+    t_hist *h;
+    t_bonk *x = (t_bonk *)newobject(bonk_class);
+    float *fp;
+    t_insig *g;
+
+    if (nsig < 1) nsig = 1;
+    if (nsig > MAXCHANNELS) nsig = MAXCHANNELS;
+    x->x_insig = (t_insig *)getbytes(nsig * sizeof(*x->x_insig));
+    dsp_setup((t_pxobject *)x, nsig);
+    x->x_cookedout = listout((t_object *)x);
+    for (j = 0, g = x->x_insig + nsig-1; j < nsig; j++, g--)
+    {
+        g->g_outlet = listout((t_object *)x);
+    }
+    x->x_cookedout = listout((t_object *)x);
+    x->x_clock = clock_new(x, (method)bonk_tick);
+
+    bonk_donew(x, period, nsig);
+    return (x);
+}
+
+void main()
+{
+        setup(&bonk_class, bonk_new, (method)bonk_free,
+            (short)sizeof(t_bonk), 0L, A_DEFLONG, A_DEFLONG, 0);
+        addmess((method)bonk_dsp,               "dsp",          0);
+        addbang((method)bonk_bang);
+        addmess((method)bonk_forget,    "forget",       0);
+        addmess((method)bonk_learn,     "learn",        A_FLOAT, 0);
+        addmess((method)bonk_thresh,    "thresh",       A_FLOAT, A_FLOAT, 0);
+        addmess((method)bonk_mask,      "mask",         A_FLOAT, A_FLOAT, 0);
+        addmess((method)bonk_minvel,    "minvel",       A_FLOAT, 0);
+        addmess((method)bonk_debounce,  "debounce", A_FLOAT, 0);
+        addmess((method)bonk_print,     "print",        A_DEFFLOAT, 0);
+        addmess((method)bonk_read,              "read",         A_DEFSYM, 0);
+        addmess((method)bonk_write,     "write",        A_DEFSYM, 0);
+        addmess((method)bonk_assist,    "assist",       A_CANT, 0);
+        addmess((method)bonk_debug,     "debug",        A_FLOAT, 0);
+        bonk_setupkernels();
+        post("bonk~ v1.00");
+        dsp_initclass();
+        rescopy('STR#',3747);
+}
+
+void bonk_assist(t_bonk *x, void *b, long m, long a, char *s)
+{
+        assist_string(3747,m,a,1,2,s);
+}
+
+    /* get current system time */
+double clock_getsystime()
+{
+
+    return gettime();
+}
+
+    /* elapsed time in milliseconds since the given system time */
+double clock_gettimesince(double prevsystime)
+{
+    return ((gettime() - prevsystime));
+}
+
+
+float qrsqrt(float f)
+{
+        return 1/sqrt(f);
+
+}
+#endif /* MSP */
diff --git a/desiredata/extra/bonk~/makefile b/desiredata/extra/bonk~/makefile
new file mode 100644
index 00000000..af6399cc
--- /dev/null
+++ b/desiredata/extra/bonk~/makefile
@@ -0,0 +1,4 @@
+NAME=bonk~
+CSYM=bonk_tilde
+
+include ../makefile
diff --git a/desiredata/extra/bonk~/templates.txt b/desiredata/extra/bonk~/templates.txt
new file mode 100644
index 00000000..f3528d78
--- /dev/null
+++ b/desiredata/extra/bonk~/templates.txt
@@ -0,0 +1,4 @@
+ 10.47   9.65  14.95  23.77  28.32  38.84  53.21  41.20  31.25  21.70  16.48 
+  6.52  13.93  27.82  58.05  24.11  35.26  35.98  37.78  22.54  13.56  10.75 
+ 30.45  28.86  29.42  21.94  29.92  35.70  38.49  32.01  28.19  27.38  22.10 
+ 66.77  46.27  28.82  25.95  22.84  20.61  20.33  14.18   6.86   8.92   7.37 
diff --git a/desiredata/extra/choice/choice.c b/desiredata/extra/choice/choice.c
new file mode 100644
index 00000000..b7bf23ab
--- /dev/null
+++ b/desiredata/extra/choice/choice.c
@@ -0,0 +1,128 @@
+/* choice -- match incoming list against a collection of stored templates. */
+
+/*  Copyright 1999 Miller Puckette.
+Permission is granted to use this software for any purpose provided you
+keep this copyright notice intact.
+
+THE AUTHOR AND HIS EMPLOYERS MAKE NO WARRANTY, EXPRESS OR IMPLIED,
+IN CONNECTION WITH THIS SOFTWARE.
+ 
+This file is downloadable from http://www.crca.ucsd.edu/~msp .
+*/
+
+#include "m_pd.h"
+#include <math.h>
+static t_class *choice_class;
+#define DIMENSION 10
+
+typedef struct _elem
+{
+    float e_age;
+    float e_weight[DIMENSION];
+} t_elem;
+
+typedef struct _choice
+{
+    t_object x_obj;
+    t_elem *x_vec;
+    int x_n;
+    int x_nonrepeat;
+} t_choice;
+
+static void *choice_new(t_float fnonrepeat)
+{
+    t_choice *x = (t_choice *)pd_new(choice_class);
+    outlet_new(&x->x_obj, gensym("float"));
+    x->x_vec = (t_elem *)getbytes(0);
+    x->x_n = 0;
+    x->x_nonrepeat = (fnonrepeat != 0);
+    return (x);
+}
+
+static void choice_clear(t_choice *x)
+{
+    x->x_vec = (t_elem *)resizebytes(x->x_vec, x->x_n * sizeof(t_elem), 0);
+    x->x_n = 0;
+}
+
+static void choice_print(t_choice *x)
+{
+    int j;
+    for (j = 0; j < x->x_n; j++)
+    {
+        t_elem *e = x->x_vec + j;
+        t_float *w = e->e_weight;
+        post("%2d age %2d \
+w %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f",
+            j, (int)(e->e_age), w[0], w[1], w[2], w[3], w[4], w[5],
+                w[6], w[7], w[8], w[9]);
+    }
+}
+
+static void choice_add(t_choice *x, t_symbol *s, int argc, t_atom *argv)
+{
+    int oldn = x->x_n, newn = oldn + 1, i;
+    t_elem *e;
+    float sum, normal;
+    x->x_vec = (t_elem *)resizebytes(x->x_vec, oldn * sizeof(t_elem),
+        newn * sizeof(t_elem));
+    x->x_n = newn;
+    e = x->x_vec + oldn;
+    e->e_age = 2;
+    
+    for (i = 0, sum = 0; i < DIMENSION; i++)
+    {
+        float f = atom_getfloatarg(i, argc, argv);
+        e->e_weight[i] = f;
+        sum += f*f;
+    }
+    normal = (float)(sum > 0 ? 1./sqrt(sum) : 1);
+    for (i = 0; i < DIMENSION; i++)
+        e->e_weight[i] *= normal;
+}
+
+static void choice_list(t_choice *x, t_symbol *s, int argc, t_atom *argv)
+{
+    int i, j;
+    float bestsum = 0;
+    int bestindex = -1;
+    t_float invec[DIMENSION];
+    for (i = 0; i < DIMENSION; i++)
+        invec[i] = atom_getfloatarg(i, argc, argv);
+    for (j = 0; j < x->x_n; j++)
+    {
+        t_elem *e = x->x_vec + j;
+        float sum;
+        for (i = 0, sum = 0; i < DIMENSION; i++)
+            sum += e->e_weight[i] * invec[i];
+        if (x->x_nonrepeat) sum *= (float)(log(e->e_age));
+        if (sum > bestsum)
+        {
+            bestsum = sum;
+            sum = 1;
+            bestindex = j;
+        }
+    }
+    if (bestindex >= 0)
+    {
+        for (j = 0; j < x->x_n; j++)
+            x->x_vec[j].e_age += 1.;
+        x->x_vec[bestindex].e_age = 1;
+    }
+    outlet_float(x->x_obj.ob_outlet, (float)bestindex);
+}
+
+static void choice_free(t_choice *x)
+{
+    freebytes(x->x_vec, x->x_n * sizeof(t_elem));
+}
+
+void choice_setup(void)
+{
+    choice_class = class_new(gensym("choice"), (t_newmethod)choice_new,
+        (t_method)choice_free, sizeof(t_choice), 0, A_DEFFLOAT, 0);
+    class_addmethod(choice_class, (t_method)choice_add, gensym("add"), A_GIMME, 0);
+    class_addmethod(choice_class, (t_method)choice_clear, gensym("clear"), 0);
+    class_addmethod(choice_class, (t_method)choice_print, gensym("print"), 0);
+    class_addlist(choice_class, choice_list);
+}
diff --git a/desiredata/extra/choice/makefile b/desiredata/extra/choice/makefile
new file mode 100644
index 00000000..7fc71159
--- /dev/null
+++ b/desiredata/extra/choice/makefile
@@ -0,0 +1,4 @@
+NAME=choice
+CSYM=choice
+
+include ../makefile
diff --git a/desiredata/extra/complex-mod~.pd b/desiredata/extra/complex-mod~.pd
new file mode 100644
index 00000000..df78a3bf
--- /dev/null
+++ b/desiredata/extra/complex-mod~.pd
@@ -0,0 +1,30 @@
+#N canvas 206 108 428 341 12;
+#X obj 142 87 inlet~;
+#X obj 315 166 cos~;
+#X obj 351 144 +~ -0.25;
+#X obj 351 166 cos~;
+#X obj 225 87 inlet~;
+#X obj 142 215 *~;
+#X obj 225 216 *~;
+#X obj 142 251 -~;
+#X obj 142 284 outlet~;
+#X obj 212 285 outlet~;
+#X obj 212 252 +~;
+#X text 140 310 positive;
+#X text 213 311 negative;
+#X obj 315 114 phasor~;
+#X obj 315 88 inlet~;
+#X connect 0 0 5 0;
+#X connect 1 0 5 1;
+#X connect 2 0 3 0;
+#X connect 3 0 6 1;
+#X connect 4 0 6 0;
+#X connect 5 0 7 0;
+#X connect 5 0 10 0;
+#X connect 6 0 7 1;
+#X connect 6 0 10 1;
+#X connect 7 0 8 0;
+#X connect 10 0 9 0;
+#X connect 13 0 2 0;
+#X connect 13 0 1 0;
+#X connect 14 0 13 0;
diff --git a/desiredata/extra/expr~/LICENSE.txt b/desiredata/extra/expr~/LICENSE.txt
new file mode 100644
index 00000000..a52b16e4
--- /dev/null
+++ b/desiredata/extra/expr~/LICENSE.txt
@@ -0,0 +1,341 @@
+
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) 19yy name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/desiredata/extra/expr~/README.txt b/desiredata/extra/expr~/README.txt
new file mode 100644
index 00000000..bf84f2ae
--- /dev/null
+++ b/desiredata/extra/expr~/README.txt
@@ -0,0 +1,97 @@
+
+You can get more information on the expr object at
+http://www.crca.ucsd.edu/~yadegari/expr.html
+
+-----------
+
+New if Version 0.4
+
+-access to variables (made by value object)
+-multiple expression separated by ;
+-added the following shorthands:
+	$y or $y1 = $y1[-1] and $y2 = $y2[-1]
+-new functions:
+	if - conditional evaluation
+	cbrt - cube root
+	erf - error function
+	erfc - complementary error function
+	expm1 - exponential minus 1,
+	log1p - logarithm of 1 plus
+	isinf - is the value infinite,
+	finite - is the value finite
+	isnan -- is the resut a nan (Not a number)
+	copysign - copy sign of a number
+	ldexp  -  multiply floating-point number by integral power of 2
+	imodf -	get signed integral value from floating-point number
+	modf - get signed fractional value from floating-point number
+	drem - floating-point remainder function
+
+   Thanks to Orm Finnendahl for adding the following functions:
+	fmod - floating-point remainder function
+	ceil - ceiling function: smallest integral value not less than argument 
+	floor - largest integral value not greater than argument
+
+------------
+
+New in Version 0.3
+-Full function functionality
+
+------------
+
+The object "expr" is used for expression evaluaion of control data.
+
+Expr~ and fexpr~ are extentions to the expr object to work with vectors.
+The expr~ object is designed to efficiently combine signal and control
+stream processing by vector operations on the basis of the block size of
+the environment.
+
+fexpr~ object provides a flexible mechanism for building FIR and
+IIR filters by evaluating expressions on a sample by sample basis
+and providing access to prior samples of the input and output audio
+streams. When fractional offset is used, fexpr~ uses linear interpolation
+to determine the value of the indexed sample. fexpr~ evaluates the
+expression for every single sample and at every evaluation previous
+samples (limited by the audio vector size) can be accessed. $x is used to
+denote a singnal input whose samples we would like to access. The syntax
+is $x followed by the inlet number and indexed by brackets, for example
+$x1[-1] specifies the previous sample of the first inlet. Therefore,
+if we are to build a simple filter which replaces every sample by
+the average of that sample and its previous one, we would use "fexpr~
+($x1[0]+$x1[-1])/2 ". For ease of when the brackets are omitted, the
+current sample is implied, so we can right the previous filter expression
+as follows:  " fexpr~ ($x1+$x1[-1])/2". To build IIR filters $y is used
+to access the previous samples of the output stream.
+
+The three objects expr, expr~, and fexpr~ are implemented in the same object
+so the files expr~.pd_linux and fexpr~.pd_linux are links to expr.pd_linux
+This release has been compiled and tested on Linux 6.0.
+
+--------
+
+Here are some syntax information: (refer to help-expr.pd for examples)
+ 
+Syntyax:
+The syntax is very close to how expression are written in
+C. Variables are specified as follows where the '#' stands
+for the inlet number:
+$i#: integer input variable
+$f#: float input variable
+$s#: symbol input variable
+
+Used for expr~ only:
+$v#: signal (vector) input (vector by vector evaluation)
+
+Used for fexpr~ only:
+$x#[n]: the sample from inlet # indexed by n, where n has to
+	satisfy 0 => n >= -vector size,
+	($x# is a shorthand for $x#[0], specifying the current sample)
+
+$y#[n]: the output value indexed by n, where n has to
+	satisfy 0 > n >= -vector size,
+	$y[n] is a shorthand for $y1[n]
+
+
+I'll appreciate hearing about bugs, comments, suggestions, ...
+
+Shahrokh Yadegari (sdy@ucsd.edu)
+7/10/02
diff --git a/desiredata/extra/expr~/fts_to_pd.h b/desiredata/extra/expr~/fts_to_pd.h
new file mode 100644
index 00000000..9ca2fc42
--- /dev/null
+++ b/desiredata/extra/expr~/fts_to_pd.h
@@ -0,0 +1,41 @@
+/* fts_to_pd.h -- alias some fts names to compile in Pd.
+
+copyright 1999 Miller Puckette;
+permission is granted to use this file for any purpose.
+*/
+
+
+#define fts_malloc malloc
+#define fts_calloc calloc
+#define fts_free free
+#define fts_realloc realloc
+#define fts_atom_t t_atom
+#define fts_object_t t_object
+typedef t_symbol *fts_symbol_t;
+
+#ifdef MSP
+#define t_atom          Atom
+#define t_symbol        Symbol
+#define pd_new(x)       newobject(x);
+#define pd_free(x)      freeobject(x);
+#define t_outlet        void
+#define t_binbuf        void
+typedef t_class         *t_pd;
+typedef float           t_floatarg;
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+
+void pd_error(void *object, char *fmt, ...);
+
+#endif /* MSP */
+
+#define post_error pd_error
+#define fts_is_floatg(x) ((x)->a_type == A_FLOAT)
+
+#define fts_new_symbol_copy gensym
+
+#define fts_symbol_name(x) ((x)->s_name)
diff --git a/desiredata/extra/expr~/makefile b/desiredata/extra/expr~/makefile
new file mode 100644
index 00000000..ff1dae4b
--- /dev/null
+++ b/desiredata/extra/expr~/makefile
@@ -0,0 +1,168 @@
+
+current: expr.pd_linux expr~.pd_linux fexpr~.pd_linux \
+     ../expr.pd_linux ../expr~.pd_linux ../fexpr~.pd_linux
+
+install: install_linux
+
+clean: clean_linux
+
+clobber: clobber_linux
+
+PDEXTERN=/usr/local/lib/pd/externs
+
+# ----------------------- NT -----------------------
+
+pd_nt: expr.dll
+
+NTOBJ =  vexp.obj vexp_fun.obj vexp_if.obj
+
+PDNTCFLAGS = /W3 /WX /DNT /DPD /nologo
+VC="C:\Program Files\Microsoft Visual Studio\Vc98"
+
+PDNTINCLUDE = /I. /I..\..\src /I$(VC)\include
+
+PDNTLDIR = $(VC)\lib
+PDNTLIB = $(PDNTLDIR)\libc.lib \
+	$(PDNTLDIR)\oldnames.lib \
+	$(PDNTLDIR)\kernel32.lib \
+	..\..\bin\pd.lib 
+
+.c.obj:
+	cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c $*.c
+
+expr.dll: $(NTOBJ)
+	link /dll /export:expr_setup /export:expr_tilde_setup \
+	    /export:fexpr_tilde_setup $(NTOBJ) $(PDNTLIB)
+	ren vexp.dll expr.dll
+	copy expr.dll ..\expr.dll
+	copy expr.dll ..\expr~.dll
+	copy expr.dll ..\fexpr~.dll
+	copy help-expr.pd ..\help-expr.pd
+
+# ----------------------- IRIX 5.x -----------------------
+
+pd_irix5: 
+
+.SUFFIXES: .pd_irix5
+
+SGICFLAGS5 = -o32 -DPD -DSGI -O2
+
+
+SGIINCLUDE =  -I/usr/people/msp/pd/pd/src
+
+.c.pd_irix5:
+	$(CC) $(SGICFLAGS5) $(SGIINCLUDE) -o $*.o -c $*.c
+	ld -elf -shared -rdata_shared -o $*.pd_irix5 $*.o
+	rm $*.o
+
+# ----------------------- IRIX 6.x -----------------------
+
+pd_irix6: 
+
+.SUFFIXES: .pd_irix6
+
+SGICFLAGS6 = -DPD -DSGI -n32 \
+	-OPT:roundoff=3 -OPT:IEEE_arithmetic=3 -OPT:cray_ivdep=true \
+	-Ofast=ip32
+
+SGICFLAGS5 = -DPD -O2 -DSGI
+
+SGIINCLUDE =  -I/usr/people/msp/pd/pd/src
+
+.c.pd_irix6:
+	$(CC) $(SGICFLAGS6) $(SGIINCLUDE) -o $*.o -c $*.c
+	ld -elf -shared -rdata_shared -o $*.pd_irix6 $*.o
+	rm $*.o
+
+# ----------------------- LINUX i386 -----------------------
+
+LINUXOBJ =  vexp.pd_linux_o vexp_fun.pd_linux_o vexp_if.pd_linux_o
+.SUFFIXES: .pd_linux_o
+
+LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer -fPIC \
+    -Wall -W -Wshadow -Wstrict-prototypes \
+    -Wno-unused -Wno-parentheses -Wno-switch 
+
+LINUXINCLUDE =  -I../../src
+
+.c.pd_linux_o:
+	$(CC) -g $(LINUXCFLAGS) $(LINUXINCLUDE) -o $*.pd_linux_o -c $*.c
+
+expr.pd_linux: $(LINUXOBJ)
+	ld -export_dynamic  -shared -o expr.pd_linux $(LINUXOBJ) -lc -lm
+	strip --strip-unneeded expr.pd_linux
+
+expr~.pd_linux: expr.pd_linux
+	-ln -s expr.pd_linux expr~.pd_linux
+
+fexpr~.pd_linux: expr.pd_linux
+	-ln -s expr.pd_linux fexpr~.pd_linux
+
+../expr.pd_linux: expr.pd_linux
+	-ln -s expr~/expr.pd_linux ../expr.pd_linux
+
+../expr~.pd_linux: expr.pd_linux
+	-ln -s expr~/expr.pd_linux ../expr~.pd_linux
+
+../fexpr~.pd_linux: expr.pd_linux
+	-ln -s expr~/expr.pd_linux ../fexpr~.pd_linux
+
+install_linux:
+	install expr.pd_linux $(PDEXTERN)
+	rm -f $(PDEXTERN)/expr~.pd_linux
+	rm -f $(PDEXTERN)/fexpr~.pd_linux
+	cd $(PDEXTERN); \
+	-ln -s expr.pd_linux expr~.pd_linux
+	-ln -s expr.pd_linux fexpr~.pd_linux
+
+
+linux_clean:
+	rm -f *.pd_linux_o *.o
+
+linux_clobber: clean
+	rm -f expr.pd_linux
+
+# ----------------------- MAC OSX -----------------------
+
+pd_darwin: expr.pd_darwin expr~.pd_darwin fexpr~.pd_darwin
+MACOSXOBJ =  vexp.pd_darwin_o vexp_fun.pd_darwin_o vexp_if.pd_darwin_o
+.SUFFIXES: .pd_darwin_o
+
+MACOSXCFLAGS = -DMACOSX -DPD -O2 -Wall -W -Wshadow -Wstrict-prototypes \
+    -Wno-unused -Wno-parentheses -Wno-switch
+
+MACOSXINCLUDE =  -I../../src
+
+.c.pd_darwin_o:
+	$(CC) -g $(MACOSXCFLAGS) $(MACOSXINCLUDE) -o $*.pd_darwin_o -c $*.c
+
+expr.pd_darwin: $(MACOSXOBJ)
+	$(CC) -bundle -undefined suppress  -flat_namespace \
+		-o expr.pd_darwin $(MACOSXOBJ)  -lm
+	rm -f ../expr.pd_darwin
+	-ln -s expr~/expr.pd_darwin ..
+
+expr~.pd_darwin: expr.pd_darwin
+	-ln -s expr.pd_darwin expr~.pd_darwin
+	rm -f ../expr~.pd_darwin
+	-ln -s expr~/expr~.pd_darwin ..
+
+fexpr~.pd_darwin: expr.pd_darwin
+	-ln -s expr.pd_darwin fexpr~.pd_darwin
+	rm -f ../fexpr~.pd_darwin
+	-ln -s expr~/fexpr~.pd_darwin ..
+
+install_darwin:
+	install expr.pd_darwin $(PDEXTERN)
+	rm -f $(PDEXTERN)/expr~.pd_darwin
+	rm -f $(PDEXTERN)/fexpr~.pd_darwin
+	cd $(PDEXTERN); \
+	-ln -s expr.pd_darwin expr~.pd_darwin; \
+	-ln -s expr.pd_darwin fexpr~.pd_darwin
+
+darwin_clean:
+	rm -f *.pd_darwin_o *.o
+
+darwin_clobber: clean
+	rm -f expr.pd_darwin
+
diff --git a/desiredata/extra/expr~/vexp.c b/desiredata/extra/expr~/vexp.c
new file mode 100644
index 00000000..7d4d7b52
--- /dev/null
+++ b/desiredata/extra/expr~/vexp.c
@@ -0,0 +1,2142 @@
+/*
+ * jMax
+ * Copyright (C) 1994, 1995, 1998, 1999 by IRCAM-Centre Georges Pompidou, Paris, France.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * See file LICENSE for further informations on licensing terms.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * 
+ * Based on Max/ISPW by Miller Puckette.
+ *
+ * Authors: Maurizio De Cecco, Francois Dechelle, Enzo Maggi, Norbert Schnell.
+ *
+ */
+
+/* "expr" was written by Shahrokh Yadegari c. 1989. -msp */
+/* "expr~" and "fexpr~" conversion by Shahrokh Yadegari c. 1999,2000 */
+
+/*
+ * Feb 2002 -   added access to variables
+ *              multiple expression support
+ *              new short hand forms for fexpr~
+ *                      now $y or $y1 = $y1[-1] and $y2 = $y2[-1]
+ *              --sdy
+ *
+ * July 2002
+ *              fixed bugs introduced in last changes in store and ET_EQ
+ *              --sdy
+ *              
+ */
+
+/*
+ * vexp.c -- a variable expression evaluator
+ *
+ * This modules implements an expression evaluator using the
+ * operator-precedence parsing.  It transforms an infix expression
+ * to a prefix stack ready to be evaluated.  The expression sysntax
+ * is close to that of C.  There are a few operators that are not
+ * supported and functions are also recognized.  Strings can be
+ * passed to functions when they are quoted in '"'s. "[]" are implememted
+ * as an easy way of accessing the content of tables, and the syntax
+ * table_name[index].
+ * Variables (inlets) are specified with the following syntax: $x#,
+ * where x is either i(integers), f(floats), and s(strings); and #
+ * is a digit that coresponds to the inlet number.  The string variables
+ * can be used as strings when they are quoted and can also be used as
+ * table names when they are followed by "[]".
+ *
+ * signal vectors have been added to this implementation:
+ * $v# denotes a signal vector
+ * $x#[index]  is the value of a sample at the index of a the signal vector
+ * $x# is the shorthand for $x#[0]
+ * $y[index]   is the value of the sample output at the index of a the
+ *             signal output
+ * "index" for $x#[index] has to have this range (0 <= index < vectorsize)
+ * "index" for $y[index]  has to have this range (0 <  index < vectorsize)
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include "vexp.h" 
+#ifdef MSP
+#undef isdigit
+#define isdigit(x)      (x >= '0' && x <= '9')
+#endif
+
+char *atoif(char *s, long int *value, long int *type);
+
+static struct ex_ex *ex_lex(struct expr *expr, long int *n);
+struct ex_ex *ex_match(struct ex_ex *eptr, long int op);
+struct ex_ex *ex_parse(struct expr *expr, struct ex_ex *iptr,
+                                        struct ex_ex *optr, long int *argc);
+struct ex_ex *ex_eval(struct expr *expr, struct ex_ex *eptr,
+                                                struct ex_ex *optr, int i);
+
+int expr_donew(struct expr *exprr, int ac, t_atom *av);
+struct ex_ex *eval_func(struct expr *expr,struct ex_ex *eptr,
+                                                struct ex_ex *optr, int i);
+struct ex_ex *eval_tab(struct expr *expr, struct ex_ex *eptr,
+                                                struct ex_ex *optr, int i);
+struct ex_ex *eval_var(struct expr *expr, struct ex_ex *eptr,
+                                                struct ex_ex *optr, int i);
+struct ex_ex *eval_store(struct expr *expr, struct ex_ex *eptr,
+                                                struct ex_ex *optr, int i);
+struct ex_ex *eval_sigidx(struct expr *expr, struct ex_ex *eptr,
+                                                struct ex_ex *optr, int i);
+static int cal_sigidx(struct ex_ex *optr,       /* The output value */
+           int i, float rem_i,      /* integer and fractinal part of index */
+           int idx,                  /* index of current fexpr~ processing */
+           int vsize,                                       /* vector size */
+           float *curvec, float *prevec);   /* current and previous table */
+t_ex_func *find_func(char *s);
+void ex_dzdetect(struct expr *expr);
+
+#define MAX_ARGS        10
+extern t_ex_func ex_funcs[];
+
+struct ex_ex nullex;
+
+void set_tokens (char *s);
+int getoken (struct expr *expr, struct ex_ex *eptr);
+void ex_print (struct ex_ex *eptr);
+#ifdef MSP
+void atom_string(t_atom *a, char *buf, unsigned int bufsize);
+
+void atom_string(t_atom *a, char *buf, unsigned int bufsize)
+{
+    char tbuf[30];
+    switch(a->a_type)
+    {
+    case A_SEMI: strcpy(buf, ";"); break;
+    case A_COMMA: strcpy(buf, ","); break;
+#ifdef PD
+    case A_POINTER:
+        strcpy(buf, "(pointer)");
+        break;
+#endif
+    case A_FLOAT:
+        sprintf(tbuf, "%g", a->a_w.w_float);
+        if (strlen(tbuf) < bufsize-1) strcpy(buf, tbuf);
+        else if (a->a_w.w_float < 0) strcpy(buf, "-");
+        else  strcat(buf, "+");
+        break;
+    case A_LONG:
+        sprintf(tbuf, "%d", a->a_w.w_long);
+        if (strlen(tbuf) < bufsize-1) strcpy(buf, tbuf);
+        else if (a->a_w.w_float < 0) strcpy(buf, "-");
+        else  strcat(buf, "+");
+        break;
+    case A_SYMBOL:
+    {   
+        char *sp;       
+        unsigned int len;
+        int quote;
+        for (sp = a->a_w.w_symbol->s_name, len = 0, quote = 0; *sp; sp++, len++)
+            if (*sp == ';' || *sp == ',' || *sp == '\\' ||
+                (*sp == '$' && sp == a->a_w.w_symbol->s_name && sp[1] >= '0'
+                    && sp[1] <= '9'))
+                quote = 1;
+        if (quote)
+        {
+            char *bp = buf, *ep = buf + (bufsize-2);
+            sp = a->a_w.w_symbol->s_name;
+            while (bp < ep && *sp)
+            {
+                if (*sp == ';' || *sp == ',' || *sp == '\\' ||
+                    (*sp == '$' && bp == buf && sp[1] >= '0' && sp[1] <= '9'))
+                        *bp++ = '\\';
+                *bp++ = *sp++;
+            }
+            if (*sp) *bp++ = '*';
+            *bp = 0;
+            /* post("quote %s -> %s", a->a_w.w_symbol->s_name, buf); */
+        }
+        else
+        {
+            if (len < bufsize-1) strcpy(buf, a->a_w.w_symbol->s_name);
+            else
+            {
+                strncpy(buf, a->a_w.w_symbol->s_name, bufsize - 2);
+                strcpy(buf + (bufsize - 2), "*");
+            }
+        }
+    }
+        break;
+#ifdef PD
+    case A_DOLLAR:
+        sprintf(buf, "$%d", a->a_w.w_index);
+        break;
+    case A_DOLLSYM:
+        sprintf(buf, "$%s", a->a_w.w_symbol->s_name);
+                break;
+#else /* MAX */
+ case A_DOLLAR:
+        sprintf(buf, "$%s", a->a_w.w_symbol->s_name);
+        break;
+#endif
+    default:
+        post("atom_string bug");
+    }
+}
+#endif /* MSP */
+/*
+ * expr_donew -- create a new "expr" object.  
+ *           returns 1 on failure, 0 on success.
+ */ 
+int
+expr_donew(struct expr *expr, int ac, t_atom *av)
+{
+        struct ex_ex *list;
+        struct ex_ex *ret;
+        long max_node = 0;              /* maximum number of nodes needed */
+        char *exp_string;
+        int exp_strlen;
+        t_binbuf *b;
+        int i;
+
+        memset(expr->exp_var, 0, MAX_VARS * sizeof (*expr->exp_var));
+#ifdef PD
+        b = binbuf_new();
+        binbuf_add(b, ac, av);
+        binbuf_gettext(b, &exp_string, &exp_strlen);
+
+#else /* MSP */
+ {
+    char *buf = getbytes(0), *newbuf;
+    int length = 0;
+    char string[250];
+    t_atom *ap;
+    int indx;
+
+    for (ap = av, indx = 0; indx < ac; indx++, ap = ++av) {
+        int newlength;
+        if ((ap->a_type == A_SEMI || ap->a_type == A_COMMA) &&
+                length && buf[length-1] == ' ') length--;
+        atom_string(ap, string, 250);
+        newlength = length + strlen(string) + 1;
+        if (!(newbuf = t_resizebytes(buf, length, newlength))) break;
+        buf = newbuf;
+        strcpy(buf + length, string);
+        length = newlength;
+        if (ap->a_type == A_SEMI) buf[length-1] = '\n';
+        else buf[length-1] = ' ';
+    }
+
+    if (length && buf[length-1] == ' ') {
+        if (newbuf = t_resizebytes(buf, length, length-1))
+        {
+            buf = newbuf;
+            length--;
+        }
+    }
+    exp_string = buf;
+    exp_strlen  = length;
+ }
+#endif
+        exp_string = (char *)t_resizebytes(exp_string, exp_strlen,exp_strlen+1);
+        exp_string[exp_strlen] = 0;
+        expr->exp_string = exp_string;
+        expr->exp_str = exp_string;
+        expr->exp_nexpr = 0;
+        ret = (struct ex_ex *) 0;
+        /*
+         * if ret == 0 it means that we have no expression
+         * so we let the pass go through to build a single null stack
+         */
+        while (*expr->exp_str || !ret) {
+                list = ex_lex(expr, &max_node);
+                if (!list) {            /* syntax error */
+                        goto error;
+                }
+                expr->exp_stack[expr->exp_nexpr] =
+                  (struct ex_ex *)fts_malloc(max_node * sizeof (struct ex_ex));
+                expr->exp_nexpr++;
+                ret = ex_match(list, (long)0);
+                if (!ret)               /* syntax error */
+                        goto error;
+                ret = ex_parse(expr,
+                        list, expr->exp_stack[expr->exp_nexpr - 1], (long *)0);
+                if (!ret)
+                        goto error;
+        }
+        *ret = nullex;
+        t_freebytes(exp_string, exp_strlen+1);
+        return (0);
+error:
+        for (i = 0; i < expr->exp_nexpr; i++) {
+                fts_free(expr->exp_stack[i]);
+                expr->exp_stack[i] = 0;
+        }
+        expr->exp_nexpr = 0;
+        if (list)
+                fts_free(list);
+        t_freebytes(exp_string, exp_strlen+1);
+        return (1);
+}
+
+/*
+ * ex_lex -- This routine is a bit more than a lexical parser since it will
+ *           also do some syntax checking.  It reads the string s and will
+ *           return a linked list of struct ex_ex. 
+ *           It will also put the number of the nodes in *n.
+ */
+struct ex_ex *
+ex_lex(struct expr *expr, long int *n)
+{
+        struct ex_ex *list_arr;
+        struct ex_ex *exptr;
+        long non = 0;           /* number of nodes */
+        long maxnode = 0;
+
+        list_arr = (struct ex_ex *)fts_malloc(sizeof (struct ex_ex) * MINODES);
+        if (! list_arr) {
+                post("ex_lex: no mem\n");
+                return ((struct ex_ex *)0);
+        }
+        exptr = list_arr;
+        maxnode = MINODES;
+
+        while (8)
+        {
+                if (non >= maxnode) {
+                        maxnode += MINODES;
+
+                        list_arr = fts_realloc((void *)list_arr,
+                                        sizeof (struct ex_ex) * maxnode);
+                        if (!list_arr) {
+                                post("ex_lex: no mem\n");
+                                return ((struct ex_ex *)0);
+                        }
+                        exptr = &(list_arr)[non];
+                }
+
+                if (getoken(expr, exptr)) {
+                        fts_free(list_arr);
+                        return ((struct ex_ex *)0);
+                }
+                non++;
+
+                if (!exptr->ex_type)
+                        break;
+
+                exptr++;
+        }
+        *n = non;
+
+        return list_arr;
+}
+
+/*
+ * ex_match -- this routine walks through the eptr and matches the
+ *             perentheses and brackets, it also converts the function
+ *             names to a pointer to the describing structure of the 
+ *             specified function
+ */
+/* operator to match */
+struct ex_ex *
+ex_match(struct ex_ex *eptr, long int op)
+{
+        int firstone = 1;
+        struct ex_ex *ret;
+        t_ex_func *fun;
+
+        for (; 8; eptr++, firstone = 0) {
+                switch (eptr->ex_type) {
+                case 0:
+                        if (!op)
+                                return (eptr);
+                        post("expr syntax error: an open %s not matched\n",
+                            op == OP_RP ? "parenthesis" : "bracket");
+                        return (exNULL);
+                case ET_INT:
+                case ET_FLT:
+                case ET_II:
+                case ET_FI:
+                case ET_SI:
+                case ET_VI:
+                case ET_SYM:
+                case ET_VSYM:
+                        continue;
+                case ET_YO:
+                        if (eptr[1].ex_type != ET_OP || eptr[1].ex_op != OP_LB)
+                                eptr->ex_type = ET_YOM1;
+                        continue;
+                case ET_XI:
+                        if (eptr[1].ex_type != ET_OP || eptr[1].ex_op != OP_LB)
+                                eptr->ex_type = ET_XI0;
+                        continue;
+                case ET_TBL:
+                case ET_FUNC:
+                case ET_LP:
+                        /* CHANGE
+                case ET_RP:
+                        */
+                case ET_LB:
+                        /* CHANGE
+                case ET_RB:
+                         */
+                        post("ex_match: unexpected type, %ld\n", eptr->ex_type);
+                        return (exNULL);
+                case ET_OP:
+                        if (op == eptr->ex_op)
+                                return (eptr);
+                        /*
+                         * if we are looking for a right peranthesis
+                         * or a right bracket and find the other kind,
+                         * it has to be a syntax error
+                         */
+                        if ((eptr->ex_op == OP_RP && op == OP_RB) ||
+                            (eptr->ex_op == OP_RB && op == OP_RP)) {
+                                post("expr syntax error: prenthesis or brackets not matched\n");
+                                return (exNULL);
+                        }
+                        /*
+                         * Up to now we have marked the unary minuses as
+                         * subrtacts.  Any minus that is the first one in
+                         * chain or is preceeded by anything except ')' and
+                         * ']' is a unary minus.
+                         */
+                        if (eptr->ex_op == OP_SUB) {
+                                ret = eptr - 1;
+                                if (firstone ||  (ret->ex_type == ET_OP &&
+                                    ret->ex_op != OP_RB && ret->ex_op != OP_RP))
+                                        eptr->ex_op = OP_UMINUS;
+                        } else if (eptr->ex_op == OP_LP) {
+                                ret = ex_match(eptr + 1, OP_RP);
+                                if (!ret)
+                                        return (ret);
+                                eptr->ex_type = ET_LP;
+                                eptr->ex_ptr = (char *) ret;
+                                eptr = ret;
+                        } else if (eptr->ex_op == OP_LB) {
+                                ret = ex_match(eptr + 1, OP_RB);
+                                if (!ret)
+                                        return (ret);
+                                eptr->ex_type = ET_LB;
+                                eptr->ex_ptr = (char *) ret;
+                                eptr = ret;
+                        }
+                        continue;
+                case ET_STR:
+                        if (eptr[1].ex_op == OP_LB) {
+                                char *tmp;
+
+                                eptr->ex_type = ET_TBL;
+                                tmp = eptr->ex_ptr;
+                                if (ex_getsym(tmp, (t_symbol **)&(eptr->ex_ptr))) {
+                                        post("expr: syntax error: problms with ex_getsym\n");
+                                        return (exNULL);
+                                }
+                                fts_free((void *)tmp);
+                        } else if (eptr[1].ex_op == OP_LP) {
+                                fun = find_func(eptr->ex_ptr);
+                                if (!fun) {
+                                        post(
+                                         "expr: error: function %s not found\n",
+                                                                eptr->ex_ptr);
+                                        return (exNULL);
+                                }
+                                eptr->ex_type = ET_FUNC;
+                                eptr->ex_ptr = (char *) fun;
+                        } else {
+                                char *tmp;
+
+                                if (eptr[1].ex_type && eptr[1].ex_type!=ET_OP){
+                                        post("expr: syntax error: bad string '%s'\n", eptr->ex_ptr);
+                                        return (exNULL);
+                                }
+                                /* it is a variable */
+                                eptr->ex_type = ET_VAR;
+                                tmp = eptr->ex_ptr;
+                                if (ex_getsym(tmp,
+                                                (t_symbol **)&(eptr->ex_ptr))) {
+                                        post("expr: variable '%s' not found",tmp);
+                                        return (exNULL);
+                                }
+                        }
+                        continue;
+                default:
+                        post("ex_match: bad type\n");
+                        return (exNULL);
+                }
+        }
+        /* NOTREACHED */
+}
+
+/*
+ * ex_parse -- This function if called when we have already done some
+ *             parsing on the expression, and we have already matched
+ *             our brackets and parenthesis.  The main job of this
+ *             function is to convert the infix expression to the
+ *             prefix form. 
+ *             First we find the operator with the lowest precedence and
+ *             put it on the stack ('optr', it is really just an array), then
+ *             we call ourself (ex_parse()), on its arguments (unary operators
+ *             only have one operator.)  
+ *             When "argc" is set it means that we are parsing the arguments
+ *             of a function and we will increment *argc anytime we find
+ *             a a segment that can qualify as an argument (counting commas).
+ *
+ *             returns 0 on syntax error
+ */
+/* number of argument separated by comma */
+struct ex_ex *
+ex_parse(struct expr *x, struct ex_ex *iptr, struct ex_ex *optr, long int *argc)
+{
+        struct ex_ex *eptr;
+        struct ex_ex *lowpre = 0;       /* pointer to the lowest precedence */
+        struct ex_ex savex;
+        long pre = HI_PRE;
+        long count;
+
+        if (!iptr) {
+                post("ex_parse: input is null, iptr = 0x%lx\n", iptr);
+                return (exNULL);
+        }
+        if (!iptr->ex_type)
+                return (exNULL);
+
+        /*
+         * the following loop finds the lowest precedence operator in the
+         * the input token list, comma is explicitly checked here since
+         * that is a special operator and is only legal in functions
+         */
+        for (eptr = iptr, count = 0; eptr->ex_type; eptr++, count++)
+                switch (eptr->ex_type) {
+                case ET_SYM:
+                case ET_VSYM:
+                        if (!argc) {
+                                post("expr: syntax error: symbols allowed for functions only\n");
+                                ex_print(eptr);
+                                return (exNULL);
+                        }
+                case ET_INT:
+                case ET_FLT:
+                case ET_II:
+                case ET_FI:
+                case ET_XI0:
+                case ET_YOM1:
+                case ET_VI:
+                case ET_VAR:
+                        if (!count && !eptr[1].ex_type) {
+                                *optr++ = *eptr;
+                                return (optr);
+                        }
+                        break;
+                case ET_XI:
+                case ET_YO:
+                case ET_SI:
+                case ET_TBL:
+                        if (eptr[1].ex_type != ET_LB) {
+                                post("expr: syntax error: brackets missing\n");
+                                ex_print(eptr);
+                                return (exNULL);
+                        }
+                        /* if this table is the only token, parse the table */
+                        if (!count &&
+                            !((struct ex_ex *) eptr[1].ex_ptr)[1].ex_type) {
+                                savex = *((struct ex_ex *) eptr[1].ex_ptr);
+                                *((struct ex_ex *) eptr[1].ex_ptr) = nullex;
+                                *optr++ = *eptr;
+                                lowpre = ex_parse(x, &eptr[2], optr, (long *)0);
+                                *((struct ex_ex *) eptr[1].ex_ptr) = savex;
+                                return(lowpre);
+                        }
+                        eptr = (struct ex_ex *) eptr[1].ex_ptr;
+                        break;
+                case ET_OP:
+                        if (eptr->ex_op == OP_COMMA) {
+                                if (!argc || !count || !eptr[1].ex_type) {
+                                        post("expr: syntax error: illegal comma\n");
+                                        ex_print(eptr[1].ex_type ? eptr : iptr);
+                                        return (exNULL);
+                                }
+                        }
+                        if (!eptr[1].ex_type) {
+                                post("expr: syntax error: missing operand\n");
+                                ex_print(iptr);
+                                return (exNULL);
+                        }
+                        if ((eptr->ex_op & PRE_MASK) <= pre) {
+                                pre = eptr->ex_op & PRE_MASK;
+                                lowpre = eptr;
+                        }
+                        break;
+                case ET_FUNC:
+                        if (eptr[1].ex_type != ET_LP) {
+                                post("expr: ex_parse: no parenthesis\n");
+                                return (exNULL);
+                        }
+                        /* if this function is the only token, parse it */
+                        if (!count &&
+                            !((struct ex_ex *) eptr[1].ex_ptr)[1].ex_type) {
+                                long ac;
+
+                                if (eptr[1].ex_ptr == (char *) &eptr[2]) {
+                                        post("expr: syntax error: missing argument\n");
+                                        ex_print(eptr);
+                                        return (exNULL);
+                                }
+                                ac = 0;
+                                savex = *((struct ex_ex *) eptr[1].ex_ptr);
+                                *((struct ex_ex *) eptr[1].ex_ptr) = nullex;
+                                *optr++ = *eptr;
+                                lowpre = ex_parse(x, &eptr[2], optr, &ac);
+                                if (!lowpre)
+                                        return (exNULL);
+                                ac++;
+                                if (ac !=
+                                    ((t_ex_func *)eptr->ex_ptr)->f_argc){
+                                        post("expr: syntax error: function '%s' needs %ld arguments\n",
+                                            ((t_ex_func *)eptr->ex_ptr)->f_name,
+                                            ((t_ex_func *)eptr->ex_ptr)->f_argc);
+                                        return (exNULL);
+                                }
+                                *((struct ex_ex *) eptr[1].ex_ptr) = savex;
+                                return (lowpre);
+                        }
+                        eptr = (struct ex_ex *) eptr[1].ex_ptr;
+                        break;
+                case ET_LP:
+                case ET_LB:
+                        if (!count &&
+                            !((struct ex_ex *) eptr->ex_ptr)[1].ex_type) {
+                                if (eptr->ex_ptr == (char *)(&eptr[1])) {
+                                        post("expr: syntax error: empty '%s'\n",
+                                            eptr->ex_type==ET_LP?"()":"[]");
+                                        ex_print(eptr);
+                                        return (exNULL);
+                                }
+                                savex = *((struct ex_ex *) eptr->ex_ptr);
+                                *((struct ex_ex *) eptr->ex_ptr) = nullex;
+                                lowpre = ex_parse(x, &eptr[1], optr, (long *)0);
+                                *((struct ex_ex *) eptr->ex_ptr) = savex;
+                                return (lowpre);
+                        }
+                        eptr = (struct ex_ex *)eptr->ex_ptr;
+                        break;
+                case ET_STR:
+                default:
+                        ex_print(eptr);
+                        post("expr: ex_parse: type = 0x%lx\n", eptr->ex_type);
+                        return (exNULL);
+                }
+
+        if (pre == HI_PRE) {
+                post("expr: syntax error: missing operation\n");
+                ex_print(iptr);
+                return (exNULL);
+        }
+        if (count < 2) {
+                post("expr: syntax error: mission operand\n");
+                ex_print(iptr);
+                return (exNULL);
+        }
+        if (count == 2) {
+                if (lowpre != iptr) {
+                        post("expr: ex_parse: unary operator should be first\n");
+                        return (exNULL);
+                }
+                if (!unary_op(lowpre->ex_op)) {
+                        post("expr: syntax error: not a uniary operator\n");
+                        ex_print(iptr);
+                        return (exNULL);
+                }
+                *optr++ = *lowpre;
+                eptr = ex_parse(x, &lowpre[1], optr, argc);
+                return (eptr);
+        }
+        if (lowpre == iptr) {
+                post("expr: syntax error: mission operand\n");
+                ex_print(iptr);
+                return (exNULL);
+        }
+        savex = *lowpre;
+        *lowpre = nullex;
+        if (savex.ex_op != OP_COMMA)
+                *optr++ = savex;
+        else
+                (*argc)++;
+        eptr = ex_parse(x, iptr, optr, argc);
+        if (eptr) {
+                eptr = ex_parse(x, &lowpre[1], eptr, argc);
+                *lowpre = savex;
+        }
+        return (eptr);
+}
+
+/*
+ * this is the devide zero check for a a non devide operator
+ */
+#define DZC(ARG1,OPR,ARG2)      (ARG1 OPR ARG2)
+
+#define EVAL(OPR);                                                      \
+eptr = ex_eval(expr, ex_eval(expr, eptr, &left, idx), &right, idx);     \
+switch (left.ex_type) {                                                 \
+case ET_INT:                                                            \
+        switch(right.ex_type) {                                         \
+        case ET_INT:                                                    \
+                if (optr->ex_type == ET_VEC) {                          \
+                        op = optr->ex_vec;                              \
+                        scalar = (float)DZC(left.ex_int, OPR, right.ex_int); \
+                        for (j = 0; j < expr->exp_vsize; j++)           \
+                                *op++ = scalar;                         \
+                } else {                                                \
+                        optr->ex_type = ET_INT;                         \
+                        optr->ex_int = DZC(left.ex_int, OPR, right.ex_int); \
+                }                                                       \
+                break;                                                  \
+        case ET_FLT:                                                    \
+                if (optr->ex_type == ET_VEC) {                          \
+                        op = optr->ex_vec;                              \
+                        scalar = DZC(((float)left.ex_int), OPR, right.ex_flt);\
+                        for (j = 0; j < expr->exp_vsize; j++)           \
+                                *op++ = scalar;                         \
+                } else {                                                \
+                        optr->ex_type = ET_FLT;                         \
+                        optr->ex_flt = DZC(((float)left.ex_int), OPR,   \
+                                                        right.ex_flt);  \
+                }                                                       \
+                break;                                                  \
+        case ET_VEC:                                                    \
+        case ET_VI:                                                     \
+                if (optr->ex_type != ET_VEC) {                          \
+                        if (optr->ex_type == ET_VI) {                   \
+                                post("expr~: Int. error %d", __LINE__); \
+                                abort();                                \
+                        }                                               \
+                        optr->ex_type = ET_VEC;                         \
+                        optr->ex_vec = (t_float *)                      \
+                          fts_malloc(sizeof (t_float)*expr->exp_vsize); \
+                }                                                       \
+                scalar = left.ex_int;                                   \
+                rp = right.ex_vec;                                      \
+                op = optr->ex_vec;                                      \
+                for (i = 0; i < expr->exp_vsize; i++) {                 \
+                        *op++ = DZC (scalar, OPR, *rp);                 \
+                        rp++;                                           \
+                }                                                       \
+                break;                                                  \
+        case ET_SYM:                                                    \
+        default:                                                        \
+                post_error((fts_object_t *) expr,                       \
+                      "expr: ex_eval(%d): bad right type %ld\n",        \
+                                              __LINE__, right.ex_type); \
+                nullret = 1;                                            \
+        }                                                               \
+        break;                                                          \
+case ET_FLT:                                                            \
+        switch(right.ex_type) {                                         \
+        case ET_INT:                                                    \
+                if (optr->ex_type == ET_VEC) {                          \
+                        op = optr->ex_vec;                              \
+                        scalar = DZC((float) left.ex_flt, OPR, right.ex_int); \
+                        for (j = 0; j < expr->exp_vsize; j++)           \
+                                *op++ = scalar;                         \
+                } else {                                                \
+                        optr->ex_type = ET_FLT;                         \
+                        optr->ex_flt = DZC(left.ex_flt, OPR, right.ex_int); \
+                }                                                       \
+                break;                                                  \
+        case ET_FLT:                                                    \
+                if (optr->ex_type == ET_VEC) {                          \
+                        op = optr->ex_vec;                              \
+                        scalar = DZC(left.ex_flt, OPR, right.ex_flt);   \
+                        for (j = 0; j < expr->exp_vsize; j++)           \
+                                *op++ = scalar;                         \
+                } else {                                                \
+                        optr->ex_type = ET_FLT;                         \
+                        optr->ex_flt= DZC(left.ex_flt, OPR, right.ex_flt); \
+                }                                                       \
+                break;                                                  \
+        case ET_VEC:                                                    \
+        case ET_VI:                                                     \
+                if (optr->ex_type != ET_VEC) {                          \
+                        if (optr->ex_type == ET_VI) {                   \
+                                post("expr~: Int. error %d", __LINE__); \
+                                abort();                                \
+                        }                                               \
+                        optr->ex_type = ET_VEC;                         \
+                        optr->ex_vec = (t_float *)                      \
+                          fts_malloc(sizeof (t_float)*expr->exp_vsize); \
+                }                                                       \
+                scalar = left.ex_flt;                                   \
+                rp = right.ex_vec;                                      \
+                op = optr->ex_vec;                                      \
+                for (i = 0; i < expr->exp_vsize; i++) {                 \
+                        *op++ = DZC(scalar, OPR, *rp);                  \
+                        rp++;                                           \
+                }                                                       \
+                break;                                                  \
+        case ET_SYM:                                                    \
+        default:                                                        \
+                post_error((fts_object_t *) expr,                       \
+                      "expr: ex_eval(%d): bad right type %ld\n",        \
+                                              __LINE__, right.ex_type); \
+                nullret = 1;                                            \
+        }                                                               \
+        break;                                                          \
+case ET_VEC:                                                            \
+case ET_VI:                                                             \
+        if (optr->ex_type != ET_VEC) {                                  \
+                if (optr->ex_type == ET_VI) {                           \
+                        post("expr~: Int. error %d", __LINE__);         \
+                        abort();                                        \
+                }                                                       \
+                optr->ex_type = ET_VEC;                                 \
+                optr->ex_vec = (t_float *)                              \
+                  fts_malloc(sizeof (t_float)*expr->exp_vsize);         \
+        }                                                               \
+        op = optr->ex_vec;                                              \
+        lp = left.ex_vec;                                               \
+        switch(right.ex_type) {                                         \
+        case ET_INT:                                                    \
+                scalar = right.ex_int;                                  \
+                for (i = 0; i < expr->exp_vsize; i++) {                 \
+                        *op++ = DZC(*lp, OPR, scalar);                  \
+                        lp++;                                           \
+                }                                                       \
+                break;                                                  \
+        case ET_FLT:                                                    \
+                scalar = right.ex_flt;                                  \
+                for (i = 0; i < expr->exp_vsize; i++) {                 \
+                        *op++ = DZC(*lp, OPR, scalar);                  \
+                        lp++;                                           \
+                }                                                       \
+                break;                                                  \
+        case ET_VEC:                                                    \
+        case ET_VI:                                                     \
+                rp = right.ex_vec;                                      \
+                for (i = 0; i < expr->exp_vsize; i++) {                 \
+                        /*                                              \
+                         * on a RISC processor one could copy           \
+                         * 8 times in each round to get a considerable  \
+                         * improvement                                  \
+                         */                                             \
+                        *op++ = DZC(*lp, OPR, *rp);                     \
+                        rp++; lp++;                                     \
+                }                                                       \
+                break;                                                  \
+        case ET_SYM:                                                    \
+        default:                                                        \
+                post_error((fts_object_t *) expr,                       \
+                      "expr: ex_eval(%d): bad right type %ld\n",        \
+                                              __LINE__, right.ex_type); \
+                nullret = 1;                                            \
+        }                                                               \
+        break;                                                          \
+case ET_SYM:                                                            \
+default:                                                                \
+                post_error((fts_object_t *) expr,                       \
+                      "expr: ex_eval(%d): bad left type %ld\n",         \
+                                              __LINE__, left.ex_type);  \
+}                                                                       \
+break;
+
+/*
+ * evaluate a unary operator, TYPE is applied to float operands
+ */
+#define EVAL_UNARY(OPR, TYPE)                                           \
+        eptr = ex_eval(expr, eptr, &left, idx);                         \
+        switch(left.ex_type) {                                          \
+        case ET_INT:                                                    \
+                if (optr->ex_type == ET_VEC) {                          \
+                        ex_mkvector(optr->ex_vec,(float)(OPR left.ex_int),\
+                                                        expr->exp_vsize);\
+                        break;                                          \
+                }                                                       \
+                optr->ex_type = ET_INT;                                 \
+                optr->ex_int = OPR left.ex_int;                         \
+                break;                                                  \
+        case ET_FLT:                                                    \
+                if (optr->ex_type == ET_VEC) {                          \
+                        ex_mkvector(optr->ex_vec, OPR (TYPE left.ex_flt),\
+                                                        expr->exp_vsize);\
+                        break;                                          \
+                }                                                       \
+                optr->ex_type = ET_FLT;                                 \
+                optr->ex_flt = OPR (TYPE left.ex_flt);                  \
+                break;                                                  \
+        case ET_VI:                                                     \
+        case ET_VEC:                                                    \
+                j = expr->exp_vsize;                                    \
+                if (optr->ex_type != ET_VEC) {                          \
+                        optr->ex_type = ET_VEC;                         \
+                        optr->ex_vec = (t_float *)                      \
+                          fts_malloc(sizeof (t_float)*expr->exp_vsize); \
+                }                                                       \
+                op = optr->ex_vec;                                      \
+                lp = left.ex_vec;                                       \
+                j = expr->exp_vsize;                                    \
+                for (i = 0; i < j; i++)                                 \
+                        *op++ = OPR (TYPE *lp++);                       \
+                break;                                                  \
+        default:                                                        \
+                post_error((fts_object_t *) expr,                       \
+                        "expr: ex_eval(%d): bad left type %ld\n",       \
+                                              __LINE__, left.ex_type);  \
+                nullret++;                                              \
+        }                                                               \
+        break;
+
+void
+ex_mkvector(t_float *fp, t_float x, int size)
+{
+        while (size--)
+                *fp++ = x;
+}
+
+/*
+ * ex_dzdetect -- divide by zero detected
+ */
+void
+ex_dzdetect(struct expr *expr)
+{
+        char *etype;
+
+        if (!expr->exp_error & EE_DZ) {
+                if (IS_EXPR(expr))
+                        etype = "expr";
+                else if (IS_EXPR_TILDE(expr))
+                        etype = "expr~";
+                else if (IS_FEXPR_TILDE(expr))
+                        etype = "fexpr~";
+                else {
+                        post ("expr -- ex_dzdetect internal error");
+                        etype = "";
+                }
+                post ("%s divide by zero detected", etype);
+                expr->exp_error |= EE_DZ;
+        }
+}
+                
+
+/*
+ * ex_eval -- evaluate the array of prefix expression
+ *            ex_eval returns the pointer to the first unevaluated node
+ *            in the array.  This is a recursive routine.
+ */
+
+/* SDY
+all the returns in this function need to be changed so that the code
+ends up at the end to check for newly allocated right and left vectors which
+need to be freed
+
+look into the variable nullret
+*/
+struct ex_ex *
+ex_eval(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+/* the expr object data pointer */
+/* the operation stack */
+/* the result pointer */
+/* the sample numnber processed for fexpr~ */
+{
+        int i, j;
+        t_float *lp, *rp, *op; /* left, right, and out pointer to vectors */
+        t_float scalar;
+        int nullret = 0;                /* did we have an error */
+        struct ex_ex left, right;       /* left and right operands */
+
+        left.ex_type = 0;
+        left.ex_int = 0;
+        right.ex_type = 0;
+        right.ex_int = 0;
+
+        if (!eptr)
+                return (exNULL);
+        switch (eptr->ex_type) {
+        case ET_INT:
+                if (optr->ex_type == ET_VEC)
+                        ex_mkvector(optr->ex_vec, (float) eptr->ex_int,
+                                                                expr->exp_vsize);
+                else
+                        *optr = *eptr;
+                return (++eptr);
+
+        case ET_FLT:
+
+                if (optr->ex_type == ET_VEC)
+                        ex_mkvector(optr->ex_vec, eptr->ex_flt, expr->exp_vsize);
+                else
+                        *optr = *eptr;
+                return (++eptr);
+
+        case ET_SYM:
+                if (optr->ex_type == ET_VEC) {
+                        post_error((fts_object_t *) expr,
+                              "expr: ex_eval: cannot turn string to vector\n");
+                        return (exNULL);
+                }
+                *optr = *eptr;
+                return (++eptr);
+        case ET_II:
+                if (eptr->ex_int == -1) {
+                        post_error((fts_object_t *) expr,
+                            "expr: ex_eval: inlet number not set\n");
+                        return (exNULL);
+                }
+                if (optr->ex_type == ET_VEC) {
+                        ex_mkvector(optr->ex_vec,
+                               (t_float)expr->exp_var[eptr->ex_int].ex_int,
+                                                                expr->exp_vsize);
+                } else {
+                        optr->ex_type = ET_INT;
+                        optr->ex_int = expr->exp_var[eptr->ex_int].ex_int;
+                }
+                return (++eptr);
+        case ET_FI:
+                if (eptr->ex_int == -1) {
+                        post_error((fts_object_t *) expr,
+                            "expr: ex_eval: inlet number not set\n");
+                        return (exNULL);
+                }
+                if (optr->ex_type == ET_VEC) {
+                        ex_mkvector(optr->ex_vec,
+                             expr->exp_var[eptr->ex_int].ex_flt, expr->exp_vsize);
+                } else {
+                        optr->ex_type = ET_FLT;
+                        optr->ex_flt = expr->exp_var[eptr->ex_int].ex_flt;
+                }
+                return (++eptr);
+
+        case ET_VSYM:
+                if (optr->ex_type == ET_VEC) {
+                        post_error((fts_object_t *) expr,
+                            "expr: IntErr. vsym in for vec out\n");
+                        return (exNULL);
+                }
+                if (eptr->ex_int == -1) {
+                        post_error((fts_object_t *) expr,
+                                "expr: ex_eval: inlet number not set\n");
+                        return (exNULL);
+                }
+                optr->ex_type = ET_SYM;
+                optr->ex_ptr = expr->exp_var[eptr->ex_int].ex_ptr;
+                return(++eptr);
+
+        case ET_VI:
+                if (optr->ex_type != ET_VEC)
+                        *optr = expr->exp_var[eptr->ex_int];
+                else if (optr->ex_vec != expr->exp_var[eptr->ex_int].ex_vec)
+                        memcpy(optr->ex_vec, expr->exp_var[eptr->ex_int].ex_vec,
+                                        expr->exp_vsize * sizeof (t_float));
+                return(++eptr);
+        case ET_VEC:
+                if (optr->ex_type != ET_VEC) {
+                        optr->ex_type = ET_VEC;
+                        optr->ex_vec = eptr->ex_vec;
+                        eptr->ex_type = ET_INT;
+                        eptr->ex_int = 0;
+                } else if (optr->ex_vec != eptr->ex_vec) {
+                        memcpy(optr->ex_vec, eptr->ex_vec,
+                                        expr->exp_vsize * sizeof (t_float));
+/* do we need to free here? or can we free higher up */
+/* SDY  the next lines do not make sense */
+post("calling fts_free\n");
+abort();
+                        fts_free(optr->ex_vec);
+                        optr->ex_type = ET_INT;
+                        eptr->ex_int = 0;
+                } else { /* this should not happen */   
+                        post("expr int. error, optr->ex_vec = %d",optr->ex_vec);
+                        abort();
+                }
+                return(++eptr);
+        case ET_XI0:
+                /* short hand for $x?[0] */
+
+                /* SDY delete the following check */
+                if (!IS_FEXPR_TILDE(expr) || optr->ex_type==ET_VEC) {
+                        post("%d:exp->exp_flags = %d", __LINE__,expr->exp_flags);
+                        abort();
+                }
+                optr->ex_type = ET_FLT;
+                optr->ex_flt = expr->exp_var[eptr->ex_int].ex_vec[idx];
+                return(++eptr);
+        case ET_YOM1:
+                /*
+                 * short hand for $y?[-1]
+                 * if we are calculating the first sample of the vector
+                 * we need to look at the previous results buffer
+                 */
+                optr->ex_type = ET_FLT;
+                if (idx == 0)
+                        optr->ex_flt =
+                        expr->exp_p_res[eptr->ex_int][expr->exp_vsize - 1];
+                else
+                        optr->ex_flt=expr->exp_tmpres[eptr->ex_int][idx-1];
+                return(++eptr);
+                
+        case ET_YO:
+        case ET_XI:
+                /* SDY delete the following */
+                if (!IS_FEXPR_TILDE(expr) || optr->ex_type==ET_VEC) {
+                        post("%d:expr->exp_flags = %d", __LINE__,expr->exp_flags);
+                        abort();
+                }
+                return (eval_sigidx(expr, eptr, optr, idx));
+                        
+        case ET_TBL:
+        case ET_SI:
+                return (eval_tab(expr, eptr, optr, idx));
+        case ET_FUNC:
+                return (eval_func(expr, eptr, optr, idx));
+        case ET_VAR:
+                return (eval_var(expr, eptr, optr, idx));
+        case ET_OP:
+                break;
+        case ET_STR:
+        case ET_LP:
+        case ET_LB:
+        default:
+                post_error((fts_object_t *) expr,
+                        "expr: ex_eval: unexpected type %d\n", eptr->ex_type);
+                return (exNULL);
+        }
+        if (!eptr[1].ex_type) {
+                post_error((fts_object_t *) expr,
+                                        "expr: ex_eval: not enough nodes 1\n");
+                return (exNULL);
+        }
+        if (!unary_op(eptr->ex_op) && !eptr[2].ex_type) {
+                post_error((fts_object_t *) expr,
+                                        "expr: ex_eval: not enough nodes 2\n");
+                return (exNULL);
+        }
+
+        switch((eptr++)->ex_op) {
+        case OP_STORE:
+                return (eval_store(expr, eptr, optr, idx));
+        case OP_NOT:
+                EVAL_UNARY(!, +);
+        case OP_NEG:
+                EVAL_UNARY(~, (long));
+        case OP_UMINUS:
+                EVAL_UNARY(-, +);
+        case OP_MUL:
+                EVAL(*);
+        case OP_ADD:
+                EVAL(+);
+        case OP_SUB:
+                EVAL(-);
+        case OP_LT:
+                EVAL(<);
+        case OP_LE:
+                EVAL(<=);
+        case OP_GT:
+                EVAL(>);
+        case OP_GE:
+                EVAL(>=);
+        case OP_EQ:
+                EVAL(==);
+        case OP_NE:
+                EVAL(!=);
+/*
+ * following operators convert their argument to integer
+ */
+#undef DZC
+#define DZC(ARG1,OPR,ARG2)      (((int)ARG1) OPR ((int)ARG2))
+        case OP_SL:
+                EVAL(<<);
+        case OP_SR:
+                EVAL(>>);
+        case OP_AND:
+                EVAL(&);
+        case OP_XOR:
+                EVAL(^);
+        case OP_OR:
+                EVAL(|);
+        case OP_LAND:
+                EVAL(&&);
+        case OP_LOR:
+                EVAL(||);
+/*
+ * for modulo we need to convert to integer and check for divide by zero
+ */
+#undef DZC
+#define DZC(ARG1,OPR,ARG2)      (((ARG2)?(((int)ARG1) OPR ((int)ARG2)) \
+                                                        : (ex_dzdetect(expr),0)))
+        case OP_MOD:
+                EVAL(%);
+/*
+ * define the divide by zero check for divide
+ */
+#undef DZC
+#define DZC(ARG1,OPR,ARG2)      (((ARG2)?(ARG1 OPR ARG2):(ex_dzdetect(expr),0)))
+        case OP_DIV:
+                EVAL(/);
+        case OP_LP:
+        case OP_RP:
+        case OP_LB:
+        case OP_RB:
+        case OP_COMMA:
+        case OP_SEMI:
+        default:
+                post_error((fts_object_t *) expr, "expr: ex_print: bad op 0x%x\n", eptr->ex_op);
+                return (exNULL);
+        }
+
+
+        /*
+         * the left and right nodes could have been transformed to vectors
+         * down the chain
+         */
+        if (left.ex_type == ET_VEC)
+                fts_free(left.ex_vec);
+        if (right.ex_type == ET_VEC)
+                fts_free(right.ex_vec);
+        if (nullret)
+                return (exNULL);
+        else
+                return (eptr);
+}
+
+/*
+ * eval_func --  evaluate a function, call ex_eval() on all the arguments
+ *               so that all of them are terminal nodes. The call the
+ *               appropriate function
+ */
+struct ex_ex *
+eval_func(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+/* the expr object data pointer */
+/* the operation stack */
+/* the result pointer */
+{
+        int i;
+        struct ex_ex args[MAX_ARGS];
+        t_ex_func *f;
+
+        f = (t_ex_func *)(eptr++)->ex_ptr;
+        if (!f || !f->f_name) {
+                return (exNULL);
+        }
+        if (f->f_argc > MAX_ARGS) {
+                post_error((fts_object_t *) expr, "expr: eval_func: asking too many arguments\n");
+                return (exNULL);
+        }
+
+        for (i = 0; i < f->f_argc; i++) {
+                args[i].ex_type = 0;
+                args[i].ex_int = 0;
+                eptr = ex_eval(expr, eptr, &args[i], idx);
+        }
+        (*f->f_func)(expr, f->f_argc, args, optr);
+        for (i = 0; i < f->f_argc; i++) {
+                if (args[i].ex_type == ET_VEC)
+                        fts_free(args[i].ex_vec);
+        }
+        return (eptr);
+}
+
+
+/*
+ * eval_store --  evaluate the '=' operator, 
+ *                make sure the first operator is a legal left operator
+ *                and call ex_eval on the right operator
+ */
+struct ex_ex *
+eval_store(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+/* the expr object data pointer */
+/* the operation stack */
+/* the result pointer */
+{
+        struct ex_ex arg;
+        int isvalue;
+        char *tbl = (char *) 0;
+        char *var = (char *) 0;
+        int badleft = 0;
+
+post("store called\n");
+ex_print(eptr);
+eptr = ex_eval(expr, ++eptr, optr, idx);
+return (eptr);
+
+#ifdef notdef /* SDY */
+        arg.ex_type = ET_INT;
+        arg.ex_int = 0;
+        if (eptr->ex_type == ET_VAR) {
+                var = (char *) eptr->ex_ptr;
+
+                eptr = ex_eval(expr, ++eptr, &arg, idx);
+                (void)max_ex_var_store(expr, (t_symbol *)var, &arg, optr);
+                if (arg.ex_type == ET_VEC)
+                        fts_free(arg.ex_vec);
+        }
+
+
+        if (eptr->ex_type == ET_SI) {
+                eptr++;
+                if (eptr->ex_type =
+        }
+
+        /* the left operator should either be a value or a array member */
+        switch (eptr->ex_type) {
+        case ET_SI:
+                if ((eptr + 1)->ex_type == OP_LB) {
+                }
+                if (!expr->exp_var[eptr->ex_int].ex_ptr) {
+                                if (!(expr->exp_error & EE_NOTABLE)) {
+                                        post("expr: syntax error: no string for inlet %d", eptr->ex_int + 1);
+                                        post("expr: No more table errors will be reported");
+                                        post("expr: till the next reset");
+                                        expr->exp_error |= EE_NOTABLE;
+                                }
+                                badleft++;
+                } else
+                        tbl = (char *) expr->exp_var[eptr->ex_int].ex_ptr;
+                break;
+        case ET_TBL:
+        }
+#endif /* SDY */
+}
+
+/*
+ * eval_tab -- evaluate a table operation
+ */
+struct ex_ex *
+eval_tab(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+/* the expr object data pointer */
+/* the operation stack */
+/* the result pointer */
+{
+        struct ex_ex arg;
+        char *tbl = (char *) 0;
+        int notable = 0;
+        
+        if (eptr->ex_type == ET_SI) {
+                if (!expr->exp_var[eptr->ex_int].ex_ptr) {
+/* SDY post_error() does not work in MAX/MSP yet
+                                post_error((fts_object_t *) expr,
+                                     "expr: syntax error: no string for inlet %d\n", eptr->ex_int + 1);
+*/
+                                if (!(expr->exp_error & EE_NOTABLE)) {
+                                        post("expr: syntax error: no string for inlet %d", eptr->ex_int + 1);
+                                        post("expr: No more table errors will be reported");
+                                        post("expr: till the next reset");
+                                        expr->exp_error |= EE_NOTABLE;
+                                }
+                                notable++;
+                } else
+                        tbl = (char *) expr->exp_var[eptr->ex_int].ex_ptr;
+        } else if (eptr->ex_type == ET_TBL)
+                tbl = (char *) eptr->ex_ptr;
+        else {
+                post_error((fts_object_t *) expr, "expr: eval_tbl: bad type %ld\n", eptr->ex_type);
+                notable++;
+
+        }
+        arg.ex_type = 0;
+        arg.ex_int = 0;
+        eptr = ex_eval(expr, ++eptr, &arg, idx);
+
+        optr->ex_type = ET_INT;
+        optr->ex_int = 0;
+        if (!notable)
+                (void)max_ex_tab(expr, (t_symbol *)tbl, &arg, optr);
+        if (arg.ex_type == ET_VEC)
+                fts_free(arg.ex_vec);
+        return (eptr);
+}
+
+/*
+ * eval_var -- evaluate a variable
+ */
+struct ex_ex *
+eval_var(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+/* the expr object data pointer */
+/* the operation stack */
+/* the result pointer */
+{
+        struct ex_ex arg;
+        char *var = (char *) 0;
+        int novar = 0;
+        
+        if (eptr->ex_type == ET_SI) {
+                if (!expr->exp_var[eptr->ex_int].ex_ptr) {
+/* SDY post_error() does not work in MAX/MSP yet
+post_error((fts_object_t *) expr,
+"expr: syntax error: no string for inlet %d\n", eptr->ex_int + 1);
+*/
+                                if (!(expr->exp_error & EE_NOVAR)) {
+                                        post("expr: syntax error: no string for inlet %d", eptr->ex_int + 1);
+                                        post("expr: No more table errors will be reported");
+                                        post("expr: till the next reset");
+                                        expr->exp_error |= EE_NOVAR;
+                                }
+                                novar++;
+                } else
+                        var = (char *) expr->exp_var[eptr->ex_int].ex_ptr;
+        } else if (eptr->ex_type == ET_VAR)
+                var = (char *) eptr->ex_ptr;
+        else {
+                post_error((fts_object_t *) expr, "expr: eval_tbl: bad type %ld\n", eptr->ex_type);
+                novar++;
+
+        }
+
+        optr->ex_type = ET_INT;
+        optr->ex_int = 0;
+        if (!novar)
+                (void)max_ex_var(expr, (t_symbol *)var, optr);
+        return (++eptr);
+}
+
+/*
+ * eval_sigidx -- evaluate the value of an indexed signal for fexpr~
+ */
+struct ex_ex *
+eval_sigidx(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+/* the expr object data pointer */
+/* the operation stack */
+/* the result pointer */
+/* the index */
+{
+        struct ex_ex arg;
+        struct ex_ex *reteptr;
+        int i = 0, j = 0;
+        float fi = 0,           /* index in float */
+              rem_i = 0;        /* remains of the float */
+        char *tbl;
+
+        arg.ex_type = 0;
+        arg.ex_int = 0;
+        reteptr = ex_eval(expr, eptr + 1, &arg, idx);
+        if (arg.ex_type == ET_FLT) {
+                fi = arg.ex_flt;                /* float index */
+                i = (int) arg.ex_flt;           /* integer index */
+                rem_i =  arg.ex_flt - i;        /* remains of integer */
+        } else if (arg.ex_type == ET_INT) {
+                fi = arg.ex_int;                /* float index */
+                i = arg.ex_int;
+                rem_i = 0;
+        } else {
+                post("eval_sigidx: bad res type (%d)", arg.ex_type);
+        }
+        optr->ex_type = ET_FLT;
+        /*
+         * indexing an input vector
+         */
+        if (eptr->ex_type == ET_XI) {
+                if (fi > 0) {
+                        if (!(expr->exp_error & EE_BI_INPUT)) {
+                                expr->exp_error |= EE_BI_INPUT;
+                          post("expr: input vector index > 0, (vector x%d[%f])",
+                                               eptr->ex_int + 1, i + rem_i);
+                                post("fexpr~: index assumed to be = 0");
+                                post("fexpr~: no error report till next reset");
+                                ex_print(eptr);
+                        }
+                        /* just replace it with zero */
+                        i = 0;
+                        rem_i = 0;
+                }
+                if (cal_sigidx(optr, i, rem_i, idx, expr->exp_vsize,
+                                        expr->exp_var[eptr->ex_int].ex_vec,
+                                                expr->exp_p_var[eptr->ex_int])) {
+                        if (!(expr->exp_error & EE_BI_INPUT)) {
+                                expr->exp_error |= EE_BI_INPUT;
+                                post("expr: input vector index <  -VectorSize, (vector x%d[%f])", eptr->ex_int + 1, fi);
+                                ex_print(eptr);
+                                post("fexpr~: index assumed to be = -%d",
+                                        expr->exp_vsize);
+                                post("fexpr~: no error report till next reset");
+                        }
+                }
+
+        /*
+         * indexing an output vector
+         */
+        } else if (eptr->ex_type == ET_YO) {
+                /* for output vectors index of zero is not legal */
+                if (fi >= 0) {
+                        if (!(expr->exp_error & EE_BI_OUTPUT)) {
+                                expr->exp_error |= EE_BI_OUTPUT;
+                                post("fexpr~: bad output index, (%f)", fi);
+                                ex_print(eptr);
+                                post("fexpr~: no error report till next reset");
+                                post("fexpr~: index assumed to be = -1");
+                        }
+                        i = -1;
+                }
+                if (eptr->ex_int >= expr->exp_nexpr) {
+                        post("fexpr~: $y%d illegal: not that many exprs",
+                                                                eptr->ex_int);
+                        optr->ex_flt = 0;
+                        return (reteptr);
+                }
+                if (cal_sigidx(optr, i, rem_i, idx, expr->exp_vsize,
+                             expr->exp_tmpres[eptr->ex_int],
+                                                expr->exp_p_res[eptr->ex_int])) {
+                        if (!(expr->exp_error & EE_BI_OUTPUT)) {
+                                expr->exp_error |= EE_BI_OUTPUT;
+                                post("fexpr~: bad output index, (%f)", fi);
+                                ex_print(eptr);
+                                post("fexpr~: index assumed to be = -%d",
+                                        expr->exp_vsize);
+                        }
+                }
+        } else {
+                optr->ex_flt = 0;
+                post("fexpr~:eval_sigidx: internal error - unknown vector (%d)",
+                                                                eptr->ex_type);
+        }
+        return (reteptr);
+}
+
+/*
+ * cal_sigidx -- given two tables (one current one previous) calculate an
+ *               evaluation of a float index into the vectors by linear
+ *               interpolation
+ *              return 0 on success, 1 on failure (index out of bound)
+ */
+static int
+cal_sigidx(struct ex_ex *optr,  /* The output value */
+           int i, float rem_i,  /* integer and fractinal part of index */
+           int idx,             /* index of current fexpr~ processing */
+           int vsize,           /* vector size */
+           float *curvec, float *prevec)        /* current and previous table */
+{
+        int n;
+
+        n = i + idx;
+        if (n > 0) {
+                /* from the curvec */
+                if (rem_i)
+                        optr->ex_flt = curvec[n] +
+                                        rem_i * (curvec[n] - curvec[n - 1]);
+                else
+                        optr->ex_flt = curvec[n];
+                return (0);
+        }
+        if (n == 0) {
+                /*
+                 * this is the case that the remaining float
+                 * is between two tables
+                 */
+                if (rem_i)
+                        optr->ex_flt = *curvec +
+                                        rem_i * (*curvec - prevec[vsize - 1]);
+                else
+                        optr->ex_flt = *curvec;
+                return (0);
+        }
+        /* find the index in the saved buffer */
+        n = vsize + n;
+        if (n > 0) {
+                if (rem_i)
+                        optr->ex_flt = prevec[n] +
+                                        rem_i * (prevec[n] - prevec[n - 1]);
+                else
+                        optr->ex_flt = prevec[n];
+                return (0);
+        }
+        /* out of bound */
+        optr->ex_flt = *prevec;
+        return (1);
+}
+
+/*
+ * getoken -- return 1 on syntax error otherwise 0
+ */
+int
+getoken(struct expr *expr, struct ex_ex *eptr)
+{
+        char *p;
+        long i;
+
+
+        if (!expr->exp_str) {
+                post("expr: getoken: expression string not set\n");
+                return (0);
+        }
+retry:
+        if (!*expr->exp_str) {
+                eptr->ex_type = 0;
+                eptr->ex_int = 0;
+                return (0);
+        }
+        if (*expr->exp_str == ';') {
+                expr->exp_str++;
+                eptr->ex_type = 0;
+                eptr->ex_int = 0;
+                return (0);
+        }
+        eptr->ex_type = ET_OP;
+        switch (*expr->exp_str++) {
+        case '\\':
+        case ' ':
+        case '\t':
+                goto retry;
+        case ';':
+                post("expr: syntax error: ';' not implemented\n");
+                return (1);
+        case ',':
+                eptr->ex_op = OP_COMMA;
+                break;
+        case '(':
+                eptr->ex_op = OP_LP;
+                break;
+        case ')':
+                eptr->ex_op = OP_RP;
+                break;
+        case ']':
+                eptr->ex_op = OP_RB;
+                break;
+        case '~':
+                eptr->ex_op = OP_NEG;
+                break;
+                /* we will take care of unary minus later */
+        case '*':
+                eptr->ex_op = OP_MUL;
+                break;
+        case '/':
+                eptr->ex_op = OP_DIV;
+                break;
+        case '%':
+                eptr->ex_op = OP_MOD;
+                break;
+        case '+':
+                eptr->ex_op = OP_ADD;
+                break;
+        case '-':
+                eptr->ex_op = OP_SUB;
+                break;
+        case '^':
+                eptr->ex_op = OP_XOR;
+                break;
+        case '[':
+                eptr->ex_op = OP_LB;
+                break;
+        case '!':
+                if (*expr->exp_str == '=') {
+                        eptr->ex_op = OP_NE;
+                        expr->exp_str++;
+                } else
+                        eptr->ex_op = OP_NOT;
+                break;
+        case '<':
+                switch (*expr->exp_str) {
+                case '<':
+                        eptr->ex_op = OP_SL;
+                        expr->exp_str++;
+                        break;
+                case '=':
+                        eptr->ex_op = OP_LE;
+                        expr->exp_str++;
+                        break;
+                default:
+                        eptr->ex_op = OP_LT;
+                        break;
+                }
+                break;
+        case '>':
+                switch (*expr->exp_str) {
+                case '>':
+                        eptr->ex_op = OP_SR;
+                        expr->exp_str++;
+                        break;
+                case '=':
+                        eptr->ex_op = OP_GE;
+                        expr->exp_str++;
+                        break;
+                default:
+                        eptr->ex_op = OP_GT;
+                        break;
+                }
+                break;
+        case '=':
+                if (*expr->exp_str++ != '=') {
+                        post("expr: syntax error: =\n");
+                        return (1);
+                }
+                eptr->ex_op = OP_EQ;
+                break;
+/* do not allow the store till the function is fixed
+                if (*expr->exp_str != '=')
+                        eptr->ex_op = OP_STORE;
+                else {
+                        expr->exp_str++;
+                        eptr->ex_op = OP_EQ;
+                }
+                break;
+*/
+
+        case '&':
+                if (*expr->exp_str == '&') {
+                        expr->exp_str++;
+                        eptr->ex_op = OP_LAND;
+                } else
+                        eptr->ex_op = OP_AND;
+                break;
+
+        case '|':
+                if ((*expr->exp_str == '|')) {
+                        expr->exp_str++;
+                        eptr->ex_op = OP_LOR;
+                } else
+                        eptr->ex_op = OP_OR;
+                break;
+        case '$':
+                switch (*expr->exp_str++) {
+                case 'I':
+                case 'i':
+                        eptr->ex_type = ET_II;
+                        break;
+                case 'F':
+                case 'f':
+                        eptr->ex_type = ET_FI;
+                        break;
+                case 'S':
+                case 's':
+                        eptr->ex_type = ET_SI;
+                        break;
+                case 'V':
+                case 'v':
+                        if (IS_EXPR_TILDE(expr)) {
+                                eptr->ex_type = ET_VI;
+                                break;
+                        }
+                        post("$v? works only for expr~");
+                        post("expr: syntax error: %s\n", &expr->exp_str[-2]);
+                        return (1);
+                case 'X':
+                case 'x':
+                        if (IS_FEXPR_TILDE(expr)) {
+                                eptr->ex_type = ET_XI;
+                                if (isdigit(*expr->exp_str))
+                                        break;
+                                /* for $x[] is a shorhand for $x1[] */
+                                eptr->ex_int = 0;
+                                goto noinletnum;
+                        }
+                        post("$x? works only for fexpr~");
+                        post("expr: syntax error: %s\n", &expr->exp_str[-2]);
+                        return (1);
+                case 'y':
+                case 'Y':
+                        if (IS_FEXPR_TILDE(expr)) {
+                                eptr->ex_type = ET_YO;
+                                /*$y takes no number */
+                                if (isdigit(*expr->exp_str))
+                                        break;
+                                /* for $y[] is a shorhand for $y1[] */
+                                eptr->ex_int = 0;
+                                goto noinletnum;
+                        }
+                        post("$y works only for fexpr~");
+                default:
+                        post("expr: syntax error: %s\n", &expr->exp_str[-2]);
+                        return (1);
+                }
+                p = atoif(expr->exp_str, &eptr->ex_op, &i);
+                if (!p) {
+                        post("expr: syntax error: %s\n", &expr->exp_str[-2]);
+                        return (1);
+                }
+                if (i != ET_INT) {
+                        post("expr: syntax error: %s\n", expr->exp_str);
+                        return (1);
+                }
+                /*
+                 * make the user inlets one based rather than zero based
+                 * therefore we decrement the number that user has supplied
+                 */
+                if (!eptr->ex_op || (eptr->ex_op)-- > MAX_VARS) {
+                 post("expr: syntax error: inlet or outlet out of range: %s\n",
+                                                             expr->exp_str);
+                        return (1);
+                }
+
+                /*
+                 * until we can change the input type of inlets on
+                 * the fly (at pd_new()
+                 * time) the first input to expr~ is always a vectore
+                 * and $f1 or $i1 is
+                 * illegal for fexr~
+                 */
+                if (eptr->ex_op == 0 &&
+                   (IS_FEXPR_TILDE(expr) ||  IS_EXPR_TILDE(expr)) &&
+                   (eptr->ex_type==ET_II || eptr->ex_type==ET_FI ||
+                                                        eptr->ex_type==ET_SI)) {
+                       post("first inlet of expr~/fexpr~ can only be a vector");
+                       return (1);
+                }
+                /* record the inlet or outlet type and check for consistency */
+                if (eptr->ex_type == ET_YO ) {
+                        /* it is an outlet  for fexpr~*/
+                        /* no need to do anything */
+                        ;
+                } else if (!expr->exp_var[eptr->ex_op].ex_type)
+                        expr->exp_var[eptr->ex_op].ex_type = eptr->ex_type;
+                else if (expr->exp_var[eptr->ex_op].ex_type != eptr->ex_type) {
+                        post("expr: syntax error: inlets can only have one type: %s\n", expr->exp_str);
+                        return (1);
+                }
+                expr->exp_str = p;
+noinletnum:
+                break;
+        case '"':
+                {
+                        struct ex_ex ex;
+
+                        p = expr->exp_str;
+                        if (!*expr->exp_str || *expr->exp_str == '"') {
+                                post("expr: syntax error: empty symbol: %s\n", --expr->exp_str);
+                                return (1);
+                        }
+                        if (getoken(expr, &ex))
+                                return (1);
+                        switch (ex.ex_type) {
+                        case ET_STR:
+                                if (ex_getsym(ex.ex_ptr, (t_symbol **)&(eptr->ex_ptr))) {
+                                        post("expr: syntax error: getoken: problms with ex_getsym\n");
+                                        return (1);
+                                }
+                                eptr->ex_type = ET_SYM;
+                                break;
+                        case ET_SI:
+                                *eptr = ex;
+                                eptr->ex_type = ET_VSYM;
+                                break;
+                        default:
+                                post("expr: syntax error: bad symbol name: %s\n", p);
+                                return (1);
+                        }
+                        if (*expr->exp_str++ != '"') {
+                                post("expr: syntax error: missing '\"'\n");
+                                return (1);
+                        }
+                        break;
+                }
+        case '.':
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+                p = atoif(--expr->exp_str, &eptr->ex_int, &eptr->ex_type);
+                if (!p)
+                        return (1);
+                expr->exp_str = p;
+                break;
+
+        default:
+                /*
+                 * has to be a string, it should either be a 
+                 * function or a table 
+                 */
+                p = --expr->exp_str;
+                for (i = 0; name_ok(*p); i++)
+                        p++;
+                if (!i) {
+                        post("expr: syntax error: %s\n", expr->exp_str);
+                        return (1);
+                }
+                eptr->ex_ptr = (char *)fts_malloc(i + 1);
+                strncpy(eptr->ex_ptr, expr->exp_str, (int) i);
+                (eptr->ex_ptr)[i] = 0;
+                expr->exp_str = p;
+                /*
+                 * we mark this as a string and later we will change this
+                 * to either a function or a table
+                 */
+                eptr->ex_type = ET_STR;
+                break;
+        }
+        return (0);
+}
+
+/*
+ * atoif -- ascii to float or integer (understands hex numbers also)
+ */
+char *
+atoif(char *s, long int *value, long int *type)
+{
+        char *p;
+        long int_val = 0;
+        int flt = 0;
+        float pos = 0;
+        float flt_val = 0;
+        int base = 10;
+
+        p = s;
+        if (*p == '0' && (p[1] == 'x' || p[1] == 'X')) {
+                base = 16;
+                p += 2;
+        }
+        while (8) {
+                switch (*p) {
+                case '.':
+                        if (flt || base != 10) {
+                                post("expr: syntax error: %s\n", s);
+                                return ((char *) 0);
+                        }
+                        flt++;
+                        pos = 10;
+                        flt_val = int_val;
+                        break;
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                        if (flt) {
+                                flt_val += (*p - '0') / pos;
+                                pos *= 10;
+                        } else {
+                                int_val *= base;
+                                int_val += (*p - '0');
+                        }
+                        break;
+                case 'a':
+                case 'b':
+                case 'c':
+                case 'd':
+                case 'e':
+                case 'f':
+                        if (base != 16 || flt) {
+                                post("expr: syntax error: %s\n", s);
+                                return ((char *) 0);
+                        }
+                        int_val *= base;
+                        int_val += (*p - 'a' + 10);
+                        break;
+                case 'A':
+                case 'B':
+                case 'C':
+                case 'D':
+                case 'E':
+                case 'F':
+                        if (base != 16 || flt) {
+                                post("expr: syntax error: %s\n", s);
+                                return ((char *) 0);
+                        }
+                        int_val *= base;
+                        int_val += (*p - 'A' + 10);
+                        break;
+                default:
+                        if (flt) {
+                                *type = ET_FLT;
+                                *((float *) value) = flt_val;
+                        } else {
+                                *type = ET_INT;
+                                *value = int_val;
+                        }
+                        return (p);
+                }
+                p++;
+        }
+}
+
+/*
+ * find_func -- returns a pointer to the found function structure
+ *              otherwise it returns 0
+ */
+t_ex_func *
+find_func(char *s)
+{
+        t_ex_func *f;
+
+        for (f = ex_funcs; f->f_name; f++)
+                if (!strcmp(f->f_name, s))
+                        return (f);
+        return ((t_ex_func *) 0);
+}
+
+
+/*
+ * ex_print -- print an expression array
+ */
+
+void
+ex_print(struct ex_ex *eptr)
+{
+
+        while (eptr->ex_type) {
+                switch (eptr->ex_type) {
+                case ET_INT:
+                        post("%ld ", eptr->ex_int);
+                        break;
+                case ET_FLT:
+                        post("%f ", eptr->ex_flt);
+                        break;
+                case ET_STR:
+                        post("%s ", eptr->ex_ptr);
+                        break;
+                case ET_TBL:
+                case ET_VAR:
+                        post("%s ", ex_symname((fts_symbol_t )eptr->ex_ptr));
+                        break;
+                case ET_SYM:
+                        post("\"%s\" ", ex_symname((fts_symbol_t )eptr->ex_ptr));
+                        break;
+                case ET_VSYM:
+                        post("\"$s%ld\" ", eptr->ex_int + 1);
+                        break;
+                case ET_FUNC:
+                        post("%s ",
+                            ((t_ex_func *)eptr->ex_ptr)->f_name);
+                        break;
+                case ET_LP:
+                        post("%c", '(');
+                        break;
+                        /* CHANGE
+                 case ET_RP:
+                         post("%c ", ')');
+                         break;
+                         */
+                case ET_LB:
+                        post("%c", '[');
+                        break;
+                        /* CHANGE
+                case ET_RB:
+                         post("%c ", ']');
+                         break;
+                         */
+                case ET_II:
+                        post("$i%ld ", eptr->ex_int + 1);
+                        break;
+                case ET_FI:
+                        post("$f%ld ", eptr->ex_int + 1);
+                        break;
+                case ET_SI:
+                        post("$s%lx ", eptr->ex_ptr);
+                        break;
+                case ET_VI:
+                        post("$v%lx ", eptr->ex_vec);
+                        break;
+                case ET_VEC:
+                        post("vec = %ld ", eptr->ex_vec);
+                        break;
+                case ET_YOM1:
+                case ET_YO:
+                        post("$y%d", eptr->ex_int + 1);
+                        break;
+                case ET_XI:
+                case ET_XI0:
+                        post("$x%d", eptr->ex_int + 1);
+                        break;
+                case ET_OP:
+                        switch (eptr->ex_op) {
+                        case OP_LP:
+                                post("%c", '(');
+                                break;
+                        case OP_RP:
+                                post("%c ", ')');
+                                break;
+                        case OP_LB:
+                                post("%c", '[');
+                                break;
+                        case OP_RB:
+                                post("%c ", ']');
+                                break;
+                        case OP_NOT:
+                                post("%c", '!');
+                                break;
+                        case OP_NEG:
+                                post("%c", '~');
+                                break;
+                        case OP_UMINUS:
+                                post("%c", '-');
+                                break;
+                        case OP_MUL:
+                                post("%c", '*');
+                                break;
+                        case OP_DIV:
+                                post("%c", '/');
+                                break;
+                        case OP_MOD:
+                                post("%c", '%');
+                                break;
+                        case OP_ADD:
+                                post("%c", '+');
+                                break;
+                        case OP_SUB:
+                                post("%c", '-');
+                                break;
+                        case OP_SL:
+                                post("%s", "<<");
+                                break;
+                        case OP_SR:
+                                post("%s", ">>");
+                                break;
+                        case OP_LT:
+                                post("%c", '<');
+                                break;
+                        case OP_LE:
+                                post("%s", "<=");
+                                break;
+                        case OP_GT:
+                                post("%c", '>');
+                                break;
+                        case OP_GE:
+                                post("%s", ">=");
+                                break;
+                        case OP_EQ:
+                                post("%s", "==");
+                                break;
+                        case OP_STORE:
+                                post("%s", "=");
+                                break;
+                        case OP_NE:
+                                post("%s", "!=");
+                                break;
+                        case OP_AND:
+                                post("%c", '&');
+                                break;
+                        case OP_XOR:
+                                post("%c", '^');
+                                break;
+                        case OP_OR:
+                                post("%c", '|');
+                                break;
+                        case OP_LAND:
+                                post("%s", "&&");
+                                break;
+                        case OP_LOR:
+                                post("%s", "||");
+                                break;
+                        case OP_COMMA:
+                                post("%c", ',');
+                                break;
+                        case OP_SEMI:
+                                post("%c", ';');
+                                break;
+                        default:
+                                post("expr: ex_print: bad op 0x%lx\n", eptr->ex_op);
+                        }
+                        break;
+                default:
+                        post("expr: ex_print: bad type 0x%lx\n", eptr->ex_type);
+                }
+                eptr++;
+        }
+        post("\n");
+}
+
+#ifdef NT
+void ABORT( void) {bug("expr");}
+#endif
diff --git a/desiredata/extra/expr~/vexp.h b/desiredata/extra/expr~/vexp.h
new file mode 100644
index 00000000..92dfb06e
--- /dev/null
+++ b/desiredata/extra/expr~/vexp.h
@@ -0,0 +1,244 @@
+/*
+ * jMax
+ * Copyright (C) 1994, 1995, 1998, 1999 by IRCAM-Centre Georges Pompidou, Paris, France.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * See file LICENSE for further informations on licensing terms.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * 
+ * Based on Max/ISPW by Miller Puckette.
+ *
+ * Authors: Maurizio De Cecco, Francois Dechelle, Enzo Maggi, Norbert Schnell.
+ *
+ */
+
+/* "expr" was written by Shahrokh Yadegari c. 1989. -msp */
+/* "expr~" and "fexpr~" conversion by Shahrokh Yadegari c. 1999,2000 */
+
+#define MSP
+#ifdef PD
+#undef MSP
+#endif
+
+#ifdef PD
+#include "m_pd.h"
+#else /* MSP */
+#include "ext.h"
+#include "z_dsp.h"
+#endif
+
+#include "fts_to_pd.h"
+/* This is put in fts_to_pd.h
+
+#ifdef MSP
+#define t_atom  Atom
+#define t_symbol Symbol
+#define pd_new(x)       newobject(x);
+#define t_outlet void
+#endif
+*/
+
+/*
+ * Currently the maximum number of variables (inlets) that are supported
+ * is 10.
+ */
+
+#define MAX_VARS        9
+#define MINODES         10 /* was 200 */
+
+/* terminal defines */
+
+/*
+ * operations
+ * (x<<16|y) x defines the level of precedence,
+ * the lower the number the lower the precedence
+ * separators are defines as operators just for convenience
+ */
+
+#define OP_SEMI         ((long)(1<<16|1))               /* ; */
+#define OP_COMMA        ((long)(2<<16|2))               /* , */
+#define OP_LOR          ((long)(3<<16|3))               /* || */
+#define OP_LAND         ((long)(4<<16|4))               /* && */
+#define OP_OR           ((long)(5<<16|5))               /* | */
+#define OP_XOR          ((long)(6<<16|6))               /* ^ */
+#define OP_AND          ((long)(7<<16|7))               /* & */
+#define OP_NE           ((long)(8<<16|8))               /* != */
+#define OP_EQ           ((long)(8<<16|9))               /* == */
+#define OP_GE           ((long)(9<<16|10))              /* >= */
+#define OP_GT           ((long)(9<<16|11))              /* > */
+#define OP_LE           ((long)(9<<16|12))              /* <= */
+#define OP_LT           ((long)(9<<16|13))              /* < */
+#define OP_SR           ((long)(10<<16|14))             /* >> */
+#define OP_SL           ((long)(10<<16|15))             /* << */
+#define OP_SUB          ((long)(11<<16|16))             /* - */
+#define OP_ADD          ((long)(11<<16|17))             /* + */
+#define OP_MOD          ((long)(12<<16|18))             /* % */
+#define OP_DIV          ((long)(12<<16|19))             /* / */
+#define OP_MUL          ((long)(12<<16|20))             /* * */
+#define OP_UMINUS       ((long)(13<<16|21))             /* - unary minus */
+#define OP_NEG          ((long)(13<<16|22))             /* ~ one complement */
+#define OP_NOT          ((long)(13<<16|23))             /* ! */
+#define OP_RB           ((long)(14<<16|24))             /* ] */
+#define OP_LB           ((long)(14<<16|25))             /* [ */
+#define OP_RP           ((long)(14<<16|26))             /* ) */
+#define OP_LP           ((long)(14<<16|27))             /* ( */
+#define OP_STORE        ((long)(15<<16|28))             /* = */
+#define HI_PRE          ((long)(100<<16))       /* infinite precedence */
+#define PRE_MASK        ((long)0xffff0000)      /* precedence level mask */
+
+struct ex_ex;
+
+#define name_ok(c)      (((c)=='_') || ((c)>='a' && (c)<='z') || \
+                        ((c)>='A' && (c)<='Z') || ((c) >= '0' && (c) <= '9'))
+#define unary_op(x)     ((x) == OP_NOT || (x) == OP_NEG || (x) == OP_UMINUS)
+
+struct ex_ex {
+        union {
+                long v_int;
+                float v_flt;
+                t_float *v_vec;         /* this is an for allocated vector */
+                long op;
+                char *ptr;
+        } ex_cont;              /* content */
+#define ex_int          ex_cont.v_int
+#define ex_flt          ex_cont.v_flt
+#define ex_vec          ex_cont.v_vec
+#define ex_op           ex_cont.op
+#define ex_ptr          ex_cont.ptr
+        long ex_type;           /* type of the node */
+};
+#define exNULL  ((struct ex_ex *)0)
+
+/* defines for ex_type */
+#define ET_INT          1               /* an int */
+#define ET_FLT          2               /* a float */
+#define ET_OP           3               /* operator */
+#define ET_STR          4               /* string */
+#define ET_TBL          5               /* a table, the content is a pointer */
+#define ET_FUNC         6               /* a function */
+#define ET_SYM          7               /* symbol ("string") */
+#define ET_VSYM         8               /* variable symbol ("$s?") */
+                                /* we treat parenthesis and brackets */
+                                /* special to keep a pointer to their */
+                                /* match in the content */
+#define ET_LP           9               /* left parenthesis */
+#define ET_LB           10              /* left bracket */
+#define ET_II           11              /* and integer inlet */
+#define ET_FI           12              /* float inlet */
+#define ET_SI           13              /* string inlet */
+#define ET_VI           14              /* signal inlet */
+#define ET_VEC          15              /* allocated signal vector */
+                                /* special types for fexpr~ */
+#define ET_YO           16              /* vector output for fexpr~ */
+#define ET_YOM1         17              /* shorthand for $y?[-1] */
+#define ET_XI           18              /* vector input for fexpr~ */
+#define ET_XI0          20              /* shorthand for $x?[0] */
+#define ET_VAR          21              /* variable */
+
+/* defines for ex_flags */
+#define EF_TYPE_MASK    0x07    /* first three bits define the type of expr */
+#define EF_EXPR         0x01    /* expr  - control in and out */
+#define EF_EXPR_TILDE   0x02    /* expr~ signal and control in, signal out */
+#define EF_FEXPR_TILDE  0x04    /* fexpr~ filter expression */
+
+#define EF_STOP         0x08    /* is it stopped used for expr~ and fexpr~ */
+#define EF_VERBOSE      0x10    /* verbose mode */
+
+#define IS_EXPR(x)        ((((x)->exp_flags&EF_TYPE_MASK)|EF_EXPR) == EF_EXPR)
+#define IS_EXPR_TILDE(x)  \
+                 ((((x)->exp_flags&EF_TYPE_MASK)|EF_EXPR_TILDE)==EF_EXPR_TILDE)
+#define IS_FEXPR_TILDE(x) \
+               ((((x)->exp_flags&EF_TYPE_MASK)|EF_FEXPR_TILDE)==EF_FEXPR_TILDE)
+
+#define SET_EXPR(x)     (x)->exp_flags |= EF_EXPR; \
+                        (x)->exp_flags &= ~EF_EXPR_TILDE;  \
+                        (x)->exp_flags &= ~EF_FEXPR_TILDE; 
+
+#define SET_EXPR_TILDE(x)       (x)->exp_flags &= ~EF_EXPR; \
+                                (x)->exp_flags |= EF_EXPR_TILDE;  \
+                                (x)->exp_flags &= ~EF_FEXPR_TILDE; 
+
+#define SET_FEXPR_TILDE(x)      (x)->exp_flags &= ~EF_EXPR; \
+                                (x)->exp_flags &= ~EF_EXPR_TILDE;  \
+                                (x)->exp_flags |= EF_FEXPR_TILDE; 
+
+/*
+ * defines for expr_error
+ */
+#define EE_DZ           0x01    /* divide by zero error */
+#define EE_BI_OUTPUT    0x02    /* Bad output index */
+#define EE_BI_INPUT     0x04    /* Bad input index */
+#define EE_NOTABLE      0x08    /* NO TABLE */
+#define EE_NOVAR        0x10    /* NO VARIABLE */
+
+typedef struct expr {
+#ifdef PD
+        t_object exp_ob;
+#else /* MSP */
+        t_pxobject exp_ob;
+#endif
+        int     exp_flags;              /* are we expr~, fexpr~, or expr */
+        int     exp_error;              /* reported errors */
+        int     exp_nexpr;              /* number of expressions */
+        char    *exp_string;            /* the full expression string */
+        char    *exp_str;               /* current parsing position */
+        t_outlet *exp_outlet[MAX_VARS];
+#ifdef PD
+        struct _exprproxy *exp_proxy;
+#else /* MAX */
+        void *exp_proxy[MAX_VARS];
+        long exp_proxy_id;
+#endif
+        struct ex_ex *exp_stack[MAX_VARS];
+        struct ex_ex exp_var[MAX_VARS];
+        struct ex_ex exp_res[MAX_VARS]; /* the evluation result */
+        t_float *exp_p_var[MAX_VARS];
+        t_float *exp_p_res[MAX_VARS];   /* the previous evaluation result */
+        t_float *exp_tmpres[MAX_VARS];          /* temporty result for fexpr~ */
+        int exp_vsize;                  /* the size of the signal vector */
+        int exp_nivec;                  /* # of vector inlets */
+        float exp_f;            /* control value to be transformed to signal */
+} t_expr;
+
+typedef struct ex_funcs {
+        char *f_name;                                   /* function name */
+        void (*f_func)(t_expr *, long, struct ex_ex *, struct ex_ex *);
+          /* the real function performing the function (void, no return!!!) */
+        long f_argc;                            /* number of arguments */
+} t_ex_func;
+
+/* function prototypes for pd-related functions called withing vexp.h */
+
+extern int max_ex_tab(struct expr *expr, t_symbol *s, struct ex_ex *arg, struct ex_ex *optr);
+extern int max_ex_var(struct expr *expr, t_symbol *s, struct ex_ex *optr);
+extern int ex_getsym(char *p, t_symbol **s);
+extern const char *ex_symname(t_symbol *s);
+void ex_mkvector(t_float *fp, t_float x, int size);
+extern void ex_size(t_expr *expr, long int argc, struct ex_ex *argv,
+                                                        struct ex_ex *optr);
+extern void ex_sum(t_expr *expr, long int argc, struct ex_ex *argv,                                                                     struct ex_ex *optr);
+extern void ex_Sum(t_expr *expr, long int argc, struct ex_ex *argv,                                                                     struct ex_ex *optr);
+extern void ex_avg(t_expr *expr, long int argc, struct ex_ex *argv,                                                                     struct ex_ex *optr);
+extern void ex_Avg(t_expr *expr, long int argc, struct ex_ex *argv,                                                                     struct ex_ex *optr);
+extern void ex_store(t_expr *expr, long int argc, struct ex_ex *argv,                                                                   struct ex_ex *optr);
+
+int value_getonly(t_symbol *s, t_float *f);
+
+#ifdef NT
+#pragma warning (disable: 4305 4244)
+
+#define abort ABORT
+void ABORT(void);
+#endif
diff --git a/desiredata/extra/expr~/vexp_fun.c b/desiredata/extra/expr~/vexp_fun.c
new file mode 100644
index 00000000..fba49b18
--- /dev/null
+++ b/desiredata/extra/expr~/vexp_fun.c
@@ -0,0 +1,1315 @@
+/*
+ * jMax
+ * Copyright (C) 1994, 1995, 1998, 1999 by IRCAM-Centre Georges Pompidou, Paris, France.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * See file LICENSE for further informations on licensing terms.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * 
+ * Based on Max/ISPW by Miller Puckette.
+ *
+ * Authors: Maurizio De Cecco, Francois Dechelle, Enzo Maggi, Norbert Schnell.
+ *
+ */
+
+/* "expr" was written by Shahrokh Yadegari c. 1989. -msp
+ *
+ * Nov. 2001 --sdy
+ *      conversion for expr~
+ *
+ * Jan, 2002 --sdy
+ *      added fmod()
+ *
+ * May  2002
+ *      added floor and ceil for expr -- Orm Finnendahl
+ *
+ * July 2002 --sdy
+ *      added the following math funtions:
+ *              cbrt - cube root
+ *              erf - error function
+ *              erfc - complementary error function
+ *              expm1 - exponential minus 1,
+ *              log1p - logarithm of 1 plus
+ *              isinf - is the value infinite,
+ *              finite - is the value finite
+ *              isnan -- is the resut a nan (Not a number)
+ *              copysign - copy sign of a number
+ *              ldexp  -  multiply floating-point number by integral power of 2
+ *              imodf - get signed integral value from floating-point number
+ *              modf - get signed fractional value from floating-point number
+ *              drem - floating-point remainder function
+ *
+ *      The following are done but not popular enough in math libss
+ *      to be included yet
+ *              hypoth - Euclidean distance function
+ *              trunc
+ *              round
+ *              nearbyint - 
+ */
+
+
+
+/*
+ * vexp_func.c -- this file include all the functions for vexp.
+ *                the first two arguments to the function are the number
+ *                of argument and an array of arguments (argc, argv)
+ *                the last argument is a pointer to a struct ex_ex for
+ *                the result.  Up do this point, the content of the
+ *                struct ex_ex that these functions receive are either
+ *                ET_INT (long), ET_FLT (float), or ET_SYM (char **, it is
+ *                char ** and not char * since NewHandle of Mac returns
+ *                a char ** for relocatability.)  The common practice in
+ *                these functions is that they figure out the type of their
+ *                result according to the type of the arguments. In general
+ *                the ET_SYM is used an ET_INT when we expect a value.
+ *                It is the users responsibility not to pass strings to the
+ *                function.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#define __STRICT_BSD__
+#include <math.h>
+#undef __STRICT_BSD__
+
+
+#include "vexp.h"
+
+/* forward declarations */
+
+static void ex_min(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_max(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_toint(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_rint(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_tofloat(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_pow(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_exp(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_log(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_ln(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_sin(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_cos(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_asin(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_acos(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_tan(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_atan(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_sinh(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_cosh(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_asinh(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_acosh(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_tanh(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_atanh(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_atan2(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_sqrt(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_fact(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_random(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_abs(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_fmod(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_ceil(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_floor(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_if(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_ldexp(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_imodf(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_modf(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+#ifndef NT
+static void ex_cbrt(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_erf(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_erfc(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_expm1(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_log1p(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_isinf(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_finite(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_isnan(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_copysign(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_drem(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+#endif
+#ifdef notdef
+/* the following will be added once they are more popular in math libraries */
+static void ex_round(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_trunc(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_nearbyint(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_hypoth(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+#endif
+ 
+
+t_ex_func ex_funcs[] = {
+        {"min",         ex_min,         2},
+        {"max",         ex_max,         2},
+        {"int",         ex_toint,       1},
+        {"rint",        ex_rint,        1},
+        {"float",       ex_tofloat,     1},
+        {"fmod",        ex_fmod,        2},
+        {"floor",       ex_floor,       2},
+        {"ceil",        ex_ceil,        2},
+        {"pow",         ex_pow,         2},
+        {"sqrt",        ex_sqrt,        1},
+        {"exp",         ex_exp,         1},
+        {"log10",       ex_log,         1},
+        {"ln",          ex_ln,          1},
+        {"log",         ex_ln,          1},
+        {"sin",         ex_sin,         1},
+        {"cos",         ex_cos,         1},
+        {"tan",         ex_tan,         1},
+        {"asin",        ex_asin,        1},
+        {"acos",        ex_acos,        1},
+        {"atan",        ex_atan,        1},
+        {"atan2",       ex_atan2,       2},
+        {"sinh",        ex_sinh,        1},
+        {"cosh",        ex_cosh,        1},
+        {"tanh",        ex_tanh,        1},
+        {"fact",        ex_fact,        1},
+        {"random",      ex_random,      2},     /* random number */
+        {"abs",         ex_abs,         1},
+        {"if",          ex_if,          3},
+        {"ldexp ",      ex_ldexp,       1},
+        {"imodf ",      ex_imodf,       1},
+        {"modf",        ex_modf,        1},
+#ifndef NT
+        {"cbrt",        ex_cbrt,        1},
+        {"erf",         ex_erf,         1},
+        {"erfc",        ex_erfc,        1},
+        {"expm1",       ex_expm1,       1},
+        {"log1p",       ex_log1p,       1},
+        {"isinf",       ex_isinf,       1},
+        {"finite",      ex_finite,      1},
+        {"isnan",       ex_isnan,       1},
+        {"copysig",     ex_copysign,    1},
+        {"drem",        ex_drem,        1},
+        {"asinh",       ex_asinh,       1},
+        {"acosh",       ex_acosh,       1},
+        {"atanh",       ex_atanh,       1},     /* hyperbolic atan */
+#endif
+#ifdef PD
+        {"size",        ex_size,        1},
+        {"sum",         ex_sum,         1},
+        {"Sum",         ex_Sum,         3},
+        {"avg",         ex_avg,         1},
+        {"Avg",         ex_Avg,         3},
+        {"store",       ex_store,       3},
+#endif
+#ifdef notdef
+/* the following will be added once they are more popular in math libraries */
+        {"round",       ex_round,       1},
+        {"trunc",       ex_trunc,       1},
+        {"nearbyint",   ex_nearbyint,   1},
+        {"hypoth",      ex_hypoth,      1},
+#endif
+        {0,             0,              0}
+};
+
+/*
+ * FUN_EVAL --  do type checking, evaluate a function,
+ *              if fltret is set return float
+ *              otherwise return value based on regular typechecking,
+ */
+#define FUNC_EVAL(left, right, func, leftfuncast, rightfuncast, optr, fltret) \
+switch (left->ex_type) {                                                \
+case ET_INT:                                                            \
+        switch(right->ex_type) {                                        \
+        case ET_INT:                                                    \
+                if (optr->ex_type == ET_VEC) {                          \
+                        op = optr->ex_vec;                              \
+                        scalar = (float)func(leftfuncast left->ex_int,  \
+                                        rightfuncast right->ex_int);    \
+                        j = e->exp_vsize;                               \
+                        while (j--)                                     \
+                                *op++ = scalar;                         \
+                } else {                                                \
+                        if (fltret) {                                   \
+                                optr->ex_type = ET_FLT;                 \
+                                optr->ex_flt = (float)func(leftfuncast  \
+                                left->ex_int, rightfuncast right->ex_int); \
+                        } else {                                        \
+                                optr->ex_type = ET_INT;                 \
+                                optr->ex_int = (int)func(leftfuncast    \
+                                left->ex_int, rightfuncast right->ex_int); \
+                        }                                               \
+                }                                                       \
+                break;                                                  \
+        case ET_FLT:                                                    \
+                if (optr->ex_type == ET_VEC) {                          \
+                        op = optr->ex_vec;                              \
+                        scalar = (float)func(leftfuncast left->ex_int,  \
+                                        rightfuncast right->ex_flt);    \
+                        j = e->exp_vsize;                               \
+                        while (j--)                                     \
+                                *op++ = scalar;                         \
+                } else {                                                \
+                        optr->ex_type = ET_FLT;                         \
+                        optr->ex_flt = (float)func(leftfuncast left->ex_int,  \
+                                        rightfuncast right->ex_flt);    \
+                }                                                       \
+                break;                                                  \
+        case ET_VEC:                                                    \
+        case ET_VI:                                                     \
+                if (optr->ex_type != ET_VEC) {                          \
+                        if (optr->ex_type == ET_VI) {                   \
+                                post("expr~: Int. error %d", __LINE__); \
+                                abort();                                \
+                        }                                               \
+                        optr->ex_type = ET_VEC;                         \
+                        optr->ex_vec = (t_float *)                      \
+                          fts_malloc(sizeof (t_float)*e->exp_vsize);    \
+                }                                                       \
+                scalar = left->ex_int;                                  \
+                rp = right->ex_vec;                                     \
+                op = optr->ex_vec;                                      \
+                j = e->exp_vsize;                                       \
+                while (j--) {                                           \
+                        *op++ = (float)func(leftfuncast scalar,         \
+                                                rightfuncast *rp);      \
+                        rp++;                                           \
+                }                                                       \
+                break;                                                  \
+        case ET_SYM:                                                    \
+        default:                                                        \
+                post_error((fts_object_t *) e,                          \
+                      "expr: FUNC_EVAL(%d): bad right type %ld\n",      \
+                                              __LINE__, right->ex_type);\
+        }                                                               \
+        break;                                                          \
+case ET_FLT:                                                            \
+        switch(right->ex_type) {                                        \
+        case ET_INT:                                                    \
+                if (optr->ex_type == ET_VEC) {                          \
+                        op = optr->ex_vec;                              \
+                        scalar = (float)func(leftfuncast left->ex_flt,  \
+                                        rightfuncast right->ex_int);    \
+                        j = e->exp_vsize;                               \
+                        while (j--)                                     \
+                                *op++ = scalar;                         \
+                } else {                                                \
+                        optr->ex_type = ET_FLT;                         \
+                        optr->ex_flt = (float)func(leftfuncast left->ex_flt,  \
+                                        rightfuncast right->ex_int);    \
+                }                                                       \
+                break;                                                  \
+        case ET_FLT:                                                    \
+                if (optr->ex_type == ET_VEC) {                          \
+                        op = optr->ex_vec;                              \
+                        scalar = (float)func(leftfuncast left->ex_flt,  \
+                                        rightfuncast right->ex_flt);    \
+                        j = e->exp_vsize;                               \
+                        while (j--)                                     \
+                                *op++ = scalar;                         \
+                } else {                                                \
+                        optr->ex_type = ET_FLT;                         \
+                        optr->ex_flt = (float)func(leftfuncast left->ex_flt,  \
+                                        rightfuncast right->ex_flt);    \
+                }                                                       \
+                break;                                                  \
+        case ET_VEC:                                                    \
+        case ET_VI:                                                     \
+                if (optr->ex_type != ET_VEC) {                          \
+                        if (optr->ex_type == ET_VI) {                   \
+                                post("expr~: Int. error %d", __LINE__); \
+                                abort();                                \
+                        }                                               \
+                        optr->ex_type = ET_VEC;                         \
+                        optr->ex_vec = (t_float *)                      \
+                          fts_malloc(sizeof (t_float) * e->exp_vsize);\
+                }                                                       \
+                scalar = left->ex_flt;                                  \
+                rp = right->ex_vec;                                     \
+                op = optr->ex_vec;                                      \
+                j = e->exp_vsize;                                       \
+                while (j--) {                                           \
+                        *op++ = (float)func(leftfuncast scalar,         \
+                                                rightfuncast *rp);      \
+                        rp++;                                           \
+                }                                                       \
+                break;                                                  \
+        case ET_SYM:                                                    \
+        default:                                                        \
+                post_error((fts_object_t *) e,                  \
+                      "expr: FUNC_EVAL(%d): bad right type %ld\n",      \
+                                              __LINE__, right->ex_type);\
+        }                                                               \
+        break;                                                          \
+case ET_VEC:                                                            \
+case ET_VI:                                                             \
+        if (optr->ex_type != ET_VEC) {                                  \
+                if (optr->ex_type == ET_VI) {                           \
+                        post("expr~: Int. error %d", __LINE__);         \
+                        abort();                                        \
+                }                                                       \
+                optr->ex_type = ET_VEC;                                 \
+                optr->ex_vec = (t_float *)                              \
+                  fts_malloc(sizeof (t_float) * e->exp_vsize);  \
+        }                                                               \
+        op = optr->ex_vec;                                              \
+        lp = left->ex_vec;                                              \
+        switch(right->ex_type) {                                        \
+        case ET_INT:                                                    \
+                scalar = right->ex_int;                                 \
+                j = e->exp_vsize;                                       \
+                while (j--) {                                           \
+                        *op++ = (float)func(leftfuncast *lp,            \
+                                                rightfuncast scalar);   \
+                        lp++;                                           \
+                }                                                       \
+                break;                                                  \
+        case ET_FLT:                                                    \
+                scalar = right->ex_flt;                                 \
+                j = e->exp_vsize;                                       \
+                while (j--) {                                           \
+                        *op++ = (float)func(leftfuncast *lp,            \
+                                                rightfuncast scalar);   \
+                        lp++;                                           \
+                }                                                       \
+                break;                                                  \
+        case ET_VEC:                                                    \
+        case ET_VI:                                                     \
+                rp = right->ex_vec;                                     \
+                j = e->exp_vsize;                                       \
+                while (j--) {                                           \
+                        /*                                              \
+                         * on a RISC processor one could copy           \
+                         * 8 times in each round to get a considerable  \
+                         * improvement                                  \
+                         */                                             \
+                        *op++ = (float)func(leftfuncast *lp,            \
+                                                rightfuncast *rp);      \
+                        rp++; lp++;                                     \
+                }                                                       \
+                break;                                                  \
+        case ET_SYM:                                                    \
+        default:                                                        \
+                post_error((fts_object_t *) e,                  \
+                      "expr: FUNC_EVAL(%d): bad right type %ld\n",      \
+                                              __LINE__, right->ex_type);\
+        }                                                               \
+        break;                                                          \
+case ET_SYM:                                                            \
+default:                                                                \
+                post_error((fts_object_t *) e,                  \
+                      "expr: FUNC_EVAL(%d): bad left type %ld\n",               \
+                                              __LINE__, left->ex_type); \
+}
+
+/*
+ * FUNC_EVAL_UNARY - evaluate a unary function,
+ *              if fltret is set return float
+ *              otherwise return value based on regular typechecking,
+ */
+#define FUNC_EVAL_UNARY(left, func, leftcast, optr, fltret)             \
+switch(left->ex_type) {                                         \
+case ET_INT:                                                    \
+        if (optr->ex_type == ET_VEC) {                          \
+                ex_mkvector(optr->ex_vec,                       \
+                (float)(func (leftcast left->ex_int)), e->exp_vsize);\
+                break;                                          \
+        }                                                       \
+        if (fltret) {                                           \
+                optr->ex_type = ET_FLT;                         \
+                optr->ex_flt = (float) func(leftcast left->ex_int); \
+                break;                                          \
+        }                                                       \
+        optr->ex_type = ET_INT;                                 \
+        optr->ex_int = (int) func(leftcast left->ex_int);       \
+        break;                                                  \
+case ET_FLT:                                                    \
+        if (optr->ex_type == ET_VEC) {                          \
+                ex_mkvector(optr->ex_vec,                       \
+                (float)(func (leftcast left->ex_flt)), e->exp_vsize);\
+                break;                                          \
+        }                                                       \
+        optr->ex_type = ET_FLT;                                 \
+        optr->ex_flt = (float) func(leftcast left->ex_flt);     \
+        break;                                                  \
+case ET_VI:                                                     \
+case ET_VEC:                                                    \
+        if (optr->ex_type != ET_VEC) {                          \
+                optr->ex_type = ET_VEC;                         \
+                optr->ex_vec = (t_float *)                      \
+                  fts_malloc(sizeof (t_float)*e->exp_vsize);    \
+        }                                                       \
+        op = optr->ex_vec;                                      \
+        lp = left->ex_vec;                                      \
+        j = e->exp_vsize;                                       \
+        while (j--)                                             \
+                *op++ = (float)(func (leftcast *lp++));         \
+        break;                                                  \
+default:                                                        \
+        post_error((fts_object_t *) e,                          \
+                "expr: FUNV_EVAL_UNARY(%d): bad left type %ld\n",\
+                                      __LINE__, left->ex_type); \
+}
+
+#undef min
+#undef max
+#define min(x,y)        (x > y ? y : x)
+#define max(x,y)        (x > y ? x : y)
+
+#define FUNC_DEF(ex_func, func, castleft, castright, fltret);                   \
+static void                                                             \
+ex_func(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)\
+{                                                                       \
+        struct ex_ex *left, *right;                                     \
+        float *op; /* output pointer */                                 \
+        float *lp, *rp;         /* left and right vector pointers */    \
+        float scalar;                                                   \
+        int j;                                                          \
+                                                                        \
+        left = argv++;                                                  \
+        right = argv;                                                   \
+        FUNC_EVAL(left, right, func, castleft, castright, optr, fltret); \
+}
+
+
+#define FUNC_DEF_UNARY(ex_func, func, cast, fltret);                    \
+static void                                                             \
+ex_func(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)\
+{                                                                       \
+        struct ex_ex *left;                                             \
+        float *op; /* output pointer */                                 \
+        float *lp, *rp;         /* left and right vector pointers */    \
+        float scalar;                                                   \
+        int j;                                                          \
+                                                                        \
+        left = argv++;                                                  \
+                                                                        \
+        FUNC_EVAL_UNARY(left, func, cast, optr, fltret);                \
+}
+
+/*
+ * ex_min -- if any of the arguments are or the output are vectors, a vector
+ *           of floats is generated otherwise the type of the result is the
+ *           type of the smaller value
+ */
+static void
+ex_min(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left, *right;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+        right = argv;
+
+        FUNC_EVAL(left, right, min, (double), (double), optr, 0);
+}
+
+/*
+ * ex_max -- if any of the arguments are or the output are vectors, a vector
+ *           of floats is generated otherwise the type of the result is the
+ *           type of the larger value
+ */
+static void
+ex_max(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left, *right;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+        right = argv;
+
+        FUNC_EVAL(left, right, max, (double), (double), optr, 0);
+}
+
+/*
+ * ex_toint -- convert to integer
+ */
+static void
+ex_toint(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+#define toint(x)        ((int)(x))
+                FUNC_EVAL_UNARY(left, toint, (int), optr, 0);
+        }
+
+#ifdef NT
+/* No rint in NT land ??? */
+double rint(double x);
+
+double
+rint(double x)
+{
+        return (floor(x + 0.5));
+}
+#endif
+
+/*
+ * ex_rint -- rint() round to the nearest int according to the common
+ *            rounding mechanism
+ */
+static void
+ex_rint(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+
+        FUNC_EVAL_UNARY(left, rint, (double), optr, 1);
+}
+
+/*
+ * ex_tofloat -- convert to float
+ */
+static void
+ex_tofloat(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+#define tofloat(x)      ((float)(x))
+        FUNC_EVAL_UNARY(left, tofloat, (int), optr, 1);
+}
+
+
+/*
+ * ex_pow -- the power of
+ */
+static void
+ex_pow(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left, *right;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+        right = argv;
+        FUNC_EVAL(left, right, pow, (double), (double), optr, 1);
+}
+
+/*
+ * ex_sqrt -- square root
+ */
+static void
+ex_sqrt(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, sqrt, (double), optr, 1);
+}
+
+/*
+ * ex_exp -- e to the power of
+ */
+static void
+ex_exp(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, exp, (double), optr, 1);
+}
+
+/*
+ * ex_log -- 10 based logarithm
+ */
+static void
+ex_log(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, log10, (double), optr, 1);
+}
+
+/*
+ * ex_ln -- natural log
+ */
+static void
+ex_ln(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, log, (double), optr, 1);
+}
+
+static void
+ex_sin(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, sin, (double), optr, 1);
+}
+
+static void
+ex_cos(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, cos, (double), optr, 1);
+}
+
+
+static void
+ex_tan(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, tan, (double), optr, 1);
+}
+
+static void
+ex_asin(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, asin, (double), optr, 1);
+}
+
+static void
+ex_acos(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, acos, (double), optr, 1);
+}
+
+
+static void
+ex_atan(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, atan, (double), optr, 1);
+}
+
+/*
+ *ex_atan2 --
+ */
+static void
+ex_atan2(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left, *right;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+        right = argv;
+        FUNC_EVAL(left, right, atan2, (double), (double), optr, 1);
+}
+
+/*
+ * ex_fmod -- floating point modulo
+ */
+static void
+ex_fmod(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left, *right;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+        right = argv;
+        FUNC_EVAL(left, right, fmod, (double), (double), optr, 1);
+}
+
+
+/*
+ * ex_floor -- floor
+ */
+static void
+ex_floor(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+        FUNC_EVAL_UNARY(left, floor, (double), optr, 1);
+}
+
+
+/*
+ * ex_ceil -- ceil
+ */
+static void
+ex_ceil(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+        FUNC_EVAL_UNARY(left, ceil, (double), optr, 1);
+}
+
+static void
+ex_sinh(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, sinh, (double), optr, 1);
+}
+
+static void
+ex_cosh(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, cosh, (double), optr, 1);
+}
+
+
+static void
+ex_tanh(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, tanh, (double), optr, 1);
+}
+
+
+#ifndef NT
+static void
+ex_asinh(t_expr *e, long argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, asinh, (double), optr, 1);
+}
+
+static void
+ex_acosh(t_expr *e, long argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, acosh, (double), optr, 1);
+}
+
+static void
+ex_atanh(t_expr *e, long argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, atanh, (double), optr, 1);
+}
+#endif
+
+static int
+ex_dofact(int i)
+{
+        int ret = 0;
+
+        if (i)
+                ret = 1;
+        else
+                return (0);
+
+        do {
+                ret *= i;
+        } while (--i);
+
+        return(ret);
+}
+
+static void
+ex_fact(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, ex_dofact,  (int), optr, 0);
+}
+
+static int
+ex_dorandom(int i1, int i2)
+{
+        return(i1 + (((i2 - i1) * (rand() & 0x7fffL)) >> 15));
+}
+/*
+ * ex_random -- return a random number
+ */
+static void
+ex_random(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left, *right;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+        right = argv;
+        FUNC_EVAL(left, right, ex_dorandom, (int), (int), optr, 0);
+}
+
+
+static void
+ex_abs(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float scalar;
+        int j;
+
+        left = argv++;
+
+        FUNC_EVAL_UNARY(left, fabs, (double), optr, 0);
+}
+
+/*
+ *ex_if -- floating point modulo
+ */
+static void
+ex_if(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        struct ex_ex *left, *right, *cond, *res;
+        float *op; /* output pointer */
+        float *lp, *rp;         /* left and right vector pointers */
+        float *cp;              /* condition pointer */
+        float leftvalue, rightvalue;
+        int j;
+
+        cond = argv++;
+        left = argv++;
+        right = argv;
+
+        switch (cond->ex_type) {
+        case ET_VEC:
+        case ET_VI:
+                if (optr->ex_type != ET_VEC) {
+                        if (optr->ex_type == ET_VI) {
+                                /* SDY remove this test */
+                                post("expr~: Int. error %d", __LINE__);
+                                return;
+                        }
+                                optr->ex_type = ET_VEC;
+                                optr->ex_vec = (t_float *)
+                                  fts_malloc(sizeof (t_float) * e->exp_vsize);
+                }
+                op = optr->ex_vec;
+                j = e->exp_vsize;
+                cp = cond->ex_vec;
+                switch (left->ex_type) {
+                case ET_INT:
+                        leftvalue = left->ex_int;
+                        switch (right->ex_type) {
+                        case ET_INT:
+                                rightvalue = right->ex_int;
+                                while (j--) {
+                                        if (*cp++)
+                                                *op++ = leftvalue;
+                                        else
+                                                *op++ = rightvalue;
+                                }
+                        return;
+                        case ET_FLT:
+                                rightvalue = right->ex_flt;
+                                while (j--) {
+                                        if (*cp++)
+                                                *op++ = leftvalue;
+                                        else
+                                                *op++ = rightvalue;
+                                }
+                                return;
+                        case ET_VEC:
+                        case ET_VI:
+                                rp = right->ex_vec;
+                                while (j--) {
+                                        if (*cp++)
+                                                *op++ = leftvalue;
+                                        else
+                                                *op++ = *rp;
+                                        rp++;
+                                }
+                                return;
+                        case ET_SYM:
+                        default:
+                                post_error((fts_object_t *) e,
+                              "expr: FUNC_EVAL(%d): bad right type %ld\n",
+                                                      __LINE__, right->ex_type);
+                                return;
+                        }
+                case ET_FLT:
+                        leftvalue = left->ex_flt;
+                        switch (right->ex_type) {
+                        case ET_INT:
+                                rightvalue = right->ex_int;
+                                while (j--) {
+                                        if (*cp++)
+                                                *op++ = leftvalue;
+                                        else
+                                                *op++ = rightvalue;
+                                }
+                                return;
+                        case ET_FLT:
+                                rightvalue = right->ex_flt;
+                                while (j--) {
+                                        if (*cp++)
+                                                *op++ = leftvalue;
+                                        else
+                                                *op++ = rightvalue;
+                                }
+                                return;
+                        case ET_VEC:
+                        case ET_VI:
+                                rp = right->ex_vec;
+                                while (j--) {
+                                        if (*cp++)
+                                                *op++ = leftvalue;
+                                        else
+                                                *op++ = *rp;
+                                        rp++;
+                                }
+                                return;
+                        case ET_SYM:
+                        default:
+                                post_error((fts_object_t *) e,
+                              "expr: FUNC_EVAL(%d): bad right type %ld\n",
+                                                      __LINE__, right->ex_type);
+                                return;
+                        }
+                case ET_VEC:
+                case ET_VI:
+                        lp = left->ex_vec;
+                        switch (right->ex_type) {
+                        case ET_INT:
+                                rightvalue = right->ex_int;
+                                while (j--) {
+                                        if (*cp++)
+                                                *op++ = *lp;
+                                        else
+                                                *op++ = rightvalue;
+                                        lp++;
+                                }
+                                return;
+                        case ET_FLT:
+                                rightvalue = right->ex_flt;
+                                while (j--) {
+                                        if (*cp++)
+                                                *op++ = *lp;
+                                        else
+                                                *op++ = rightvalue;
+                                        lp++;
+                                }
+                                return;
+                        case ET_VEC:
+                        case ET_VI:
+                                rp = right->ex_vec;
+                                while (j--) {
+                                        if (*cp++)
+                                                *op++ = *lp;
+                                        else
+                                                *op++ = *rp;
+                                        lp++; rp++;
+                                }
+                                return;
+                        case ET_SYM:
+                        default:
+                                post_error((fts_object_t *) e,
+                              "expr: FUNC_EVAL(%d): bad right type %ld\n",
+                                                      __LINE__, right->ex_type);
+                                return;
+                        }
+                case ET_SYM:
+                default:
+                        post_error((fts_object_t *) e,
+                      "expr: FUNC_EVAL(%d): bad left type %ld\n",
+                                              __LINE__, left->ex_type);
+                        return;
+                }
+        case ET_INT:
+                if (cond->ex_int)
+                        res = left;
+                else
+                        res = right;
+                break;
+        case ET_FLT:
+                if (cond->ex_flt)
+                        res = left;
+                else
+                        res = right;
+                break;
+        case ET_SYM:
+        default:
+                post_error((fts_object_t *) e,
+              "expr: FUNC_EVAL(%d): bad condition type %ld\n",
+                                      __LINE__, cond->ex_type);
+                return;
+        }
+        switch(res->ex_type) {
+        case ET_INT:
+                if (optr->ex_type == ET_VEC) {
+                        ex_mkvector(optr->ex_vec, (float)res->ex_int,
+                                                                e->exp_vsize);
+                        return;
+                }
+                *optr = *res;
+                return;
+        case ET_FLT:
+                if (optr->ex_type == ET_VEC) {
+                        ex_mkvector(optr->ex_vec, (float)res->ex_flt,
+                                                                e->exp_vsize);
+                        return;
+                }
+                *optr = *res;
+                return;
+        case ET_VEC:
+        case ET_VI:
+                if (optr->ex_type != ET_VEC) {
+                        if (optr->ex_type == ET_VI) {
+                                /* SDY remove this test */
+                                post("expr~: Int. error %d", __LINE__);
+                                return;
+                        }
+                                optr->ex_type = ET_VEC;
+                                optr->ex_vec = (t_float *)
+                                  fts_malloc(sizeof (t_float) * e->exp_vsize);
+                }
+                memcpy(optr->ex_vec, res->ex_vec, e->exp_vsize*sizeof(t_float));
+                return;
+        case ET_SYM:
+        default:
+                post_error((fts_object_t *) e,
+              "expr: FUNC_EVAL(%d): bad res type %ld\n",
+                                      __LINE__, res->ex_type);
+                return;
+        }
+        
+}
+
+/*
+ * ex_imodf -   extract signed integral value from floating-point number
+ */
+static double
+imodf(double x)
+{
+        double  xx;
+
+        modf(x, &xx);
+        return (xx);
+}
+FUNC_DEF_UNARY(ex_imodf, imodf, (double), 1);
+
+/*
+ * ex_modf - extract signed  fractional value from floating-point number
+ *
+ *  using fracmodf because fmodf() is alrady defined in a .h file
+ */
+static double
+fracmodf(double x)
+{
+        double  xx;
+
+        return(modf(x, &xx));
+}
+FUNC_DEF_UNARY(ex_modf, fracmodf, (double), 1);
+
+/*
+ * ex_ldexp  -  multiply floating-point number by integral power of 2
+ */
+FUNC_DEF(ex_ldexp, ldexp, (double), (int), 1);
+
+#ifndef NT
+/*
+ * ex_cbrt - cube root
+ */
+FUNC_DEF_UNARY(ex_cbrt, cbrt, (double), 1);
+
+/*
+ * ex_erf - error function
+ */
+FUNC_DEF_UNARY(ex_erf, erf, (double), 1);
+
+/*
+ * ex_erfc - complementary error function
+ */
+FUNC_DEF_UNARY(ex_erfc, erfc, (double), 1);
+
+/*
+ * ex_expm1 - exponential minus 1,
+ */
+FUNC_DEF_UNARY(ex_expm1, expm1, (double), 1);
+
+/*
+ * ex_log1p - logarithm of 1 plus
+ */
+FUNC_DEF_UNARY(ex_log1p, log1p, (double), 1);
+
+/*
+ * ex_isinf - is the value infinite,
+ */
+FUNC_DEF_UNARY(ex_isinf, isinf, (double), 0);
+
+/*
+ * ex_finite - is the value finite
+ */
+FUNC_DEF_UNARY(ex_finite, finite, (double), 0);
+
+/*
+ * ex_isnan -- is the resut a nan (Not a number)
+ */
+FUNC_DEF_UNARY(ex_isnan, isnan, (double), 0);
+
+/*
+ * ex_copysign - copy sign of a number
+ */
+FUNC_DEF(ex_copysign, copysign, (double), (double), 1);
+
+/*
+ * ex_drem - floating-point remainder function
+ */
+FUNC_DEF(ex_drem, drem, (double), (double), 1);
+#endif
+
+#ifdef notdef
+/* the following will be added once they are more popular in math libraries */
+/*
+ * ex_hypoth - Euclidean distance function
+ */
+FUNC_DEF(ex_hypoth, hypoth, (double), (double), 1);
+
+/*
+ * ex_round -  round to nearest integer, away from zero
+ */
+FUNC_DEF_UNARY(ex_round, round, (double), 1);
+
+/*
+ * ex_trunc -  round to interger, towards zero
+ */
+FUNC_DEF_UNARY(ex_trunc, trunc, (double), 1);
+
+/*
+ * ex_nearbyint -  round to nearest integer
+ */
+FUNC_DEF_UNARY(ex_nearbyint, nearbyint, (double), 1);
+#endif
diff --git a/desiredata/extra/expr~/vexp_if.c b/desiredata/extra/expr~/vexp_if.c
new file mode 100644
index 00000000..08dc55c3
--- /dev/null
+++ b/desiredata/extra/expr~/vexp_if.c
@@ -0,0 +1,1223 @@
+/*
+ * jMax
+ * Copyright (C) 1994, 1995, 1998, 1999 by IRCAM-Centre Georges Pompidou, Paris, France.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * See file LICENSE for further informations on licensing terms.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * 
+ * Based on Max/ISPW by Miller Puckette.
+ *
+ * Authors: Maurizio De Cecco, Francois Dechelle, Enzo Maggi, Norbert Schnell.
+ *
+ */
+
+/* "expr" was written by Shahrokh Yadegari c. 1989. -msp */
+/* "expr~" and "fexpr~" conversion by Shahrokh Yadegari c. 1999,2000 */
+
+/*
+ * Feb 2002 - added access to variables
+ *            multiple expression support
+ *            new short hand forms for fexpr~
+ *              now $y or $y1 = $y1[-1] and $y2 = $y2[-1]
+ * --sdy
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "vexp.h"
+
+static char *exp_version = "0.4";
+
+extern struct ex_ex *ex_eval(struct expr *expr, struct ex_ex *eptr,
+                                                struct ex_ex *optr, int n);
+
+#ifdef PD
+static t_class *expr_class;
+static t_class *expr_tilde_class;
+static t_class *fexpr_tilde_class;
+#else /* MSP */
+void *expr_tilde_class;
+#endif
+
+
+/*------------------------- expr class -------------------------------------*/
+
+extern int expr_donew(struct expr *expr, int ac, t_atom *av);
+
+/*#define EXPR_DEBUG*/
+
+static void expr_bang(t_expr *x);
+t_int *expr_perform(t_int *w);
+
+
+static void
+expr_list(t_expr *x, t_symbol *s, int argc, const fts_atom_t *argv)
+{
+        int i;
+
+        if (argc > MAX_VARS) argc = MAX_VARS;
+
+        for (i = 0; i < argc; i++)
+        {
+                if (argv[i].a_type == A_FLOAT)
+                {
+                        if (x->exp_var[i].ex_type == ET_FI)
+                                x->exp_var[i].ex_flt = argv[i].a_w.w_float;
+                        else if (x->exp_var[i].ex_type == ET_II)
+                                x->exp_var[i].ex_int = argv[i].a_w.w_float;
+                        else if (x->exp_var[i].ex_type)
+                            pd_error(x, "expr: type mismatch");
+                }
+                else if (argv[i].a_type == A_SYMBOL)
+                {
+                        if (x->exp_var[i].ex_type == ET_SI)
+                                x->exp_var[i].ex_ptr = (char *)argv[i].a_w.w_symbol;
+                        else if (x->exp_var[i].ex_type)
+                            pd_error(x, "expr: type mismatch");
+                }
+        }
+        expr_bang(x);
+}
+
+static void
+expr_flt(t_expr *x, t_float f, int in)
+{
+        if (in > MAX_VARS)
+                return;
+
+        if (x->exp_var[in].ex_type == ET_FI)
+                x->exp_var[in].ex_flt = f;
+        else if (x->exp_var[in].ex_type == ET_II)
+                x->exp_var[in].ex_int = f;
+}
+
+static t_class *exprproxy_class;
+
+typedef struct _exprproxy {
+        t_pd p_pd;
+        int p_index;
+        t_expr *p_owner;
+        struct _exprproxy *p_next;
+} t_exprproxy;
+
+t_exprproxy *exprproxy_new(t_expr *owner, int indx);
+void exprproxy_float(t_exprproxy *p, t_floatarg f);
+
+t_exprproxy *
+exprproxy_new(t_expr *owner, int indx)
+{
+        t_exprproxy *x = (t_exprproxy *)pd_new(exprproxy_class);
+        x->p_owner = owner;
+        x->p_index = indx;
+        x->p_next = owner->exp_proxy;
+        owner->exp_proxy = x;
+        return (x);
+}
+
+void
+exprproxy_float(t_exprproxy *p, t_floatarg f)
+{
+        t_expr *x = p->p_owner;
+        int in = p->p_index;
+
+        if (in > MAX_VARS)
+                return;
+
+        if (x->exp_var[in].ex_type == ET_FI)
+                x->exp_var[in].ex_flt = f;
+        else if (x->exp_var[in].ex_type == ET_II)
+                x->exp_var[in].ex_int = f;
+}
+
+/* method definitions */
+static void
+expr_ff(t_expr *x)
+{
+        t_exprproxy *y;
+        int i;
+        
+        y = x->exp_proxy;
+        while (y)
+        {
+                x->exp_proxy = y->p_next;
+#ifdef PD
+                pd_free(&y->p_pd);
+#else /*MSP */
+        /* SDY find out what needs to be called for MSP */
+
+#endif
+                y = x->exp_proxy;
+        }
+        for (i = 0 ; i < x->exp_nexpr; i++);
+                if (x->exp_stack[i])
+                        fts_free(x->exp_stack[i]);
+/*
+ * SDY free all the allocated buffers here for expr~ and fexpr~
+ * check to see if there are others
+ */
+        for (i = 0; i < MAX_VARS; i++) {
+                if (x->exp_p_var[i])
+                        fts_free(x->exp_p_var[i]);
+                if (x->exp_p_res[i])
+                        fts_free(x->exp_p_res[i]);
+                if (x->exp_tmpres[i])
+                        fts_free(x->exp_tmpres[i]);
+        }
+
+
+}
+
+static void
+expr_bang(t_expr *x)
+{
+        int i;
+
+#ifdef EXPR_DEBUG
+        {
+                struct ex_ex *eptr;
+
+                for (i = 0, eptr = x->exp_var;  ; eptr++, i++)
+                {
+                        if (!eptr->ex_type)
+                                break;
+                        switch (eptr->ex_type)
+                        {
+                        case ET_II:
+                                fprintf(stderr,"ET_II: %d \n", eptr->ex_int);
+                                break;
+
+                        case ET_FI:
+                                fprintf(stderr,"ET_FT: %f \n", eptr->ex_flt);
+                                break;
+
+                        default:
+                                fprintf(stderr,"oups\n");
+                        }
+                }
+        }
+#endif
+        /* banging a signal or filter object means nothing */
+        if (!IS_EXPR(x))
+                return;
+
+        for (i = x->exp_nexpr - 1; i > -1 ; i--) {
+                if (!ex_eval(x, x->exp_stack[i], &x->exp_res[i], 0)) {
+                        /*fprintf(stderr,"expr_bang(error evaluation)\n"); */
+                /*  SDY now that we have mutiple ones, on error we should
+                 * continue
+                        return;
+                 */
+                }
+                switch(x->exp_res[i].ex_type) {
+                case ET_INT:
+                        outlet_float(x->exp_outlet[i], 
+                                        (t_float) x->exp_res[i].ex_int);
+                        break;
+
+                case ET_FLT:
+                        outlet_float(x->exp_outlet[i],  x->exp_res[i].ex_flt);
+                        break;
+
+                case ET_SYM:
+                        /* CHANGE this will have to be taken care of */
+
+                default:
+                        post("expr: bang: unrecognized result %ld\n", x->exp_res[i].ex_type);
+                }
+        }
+}
+
+static t_expr *
+#ifdef PD
+expr_new(t_symbol *s, int ac, t_atom *av)
+#else /* MSP */
+Nexpr_new(t_symbol *s, int ac, t_atom *av)
+#endif
+{
+        struct expr *x;
+        int i, ninlet;
+        struct ex_ex *eptr;
+        t_atom fakearg;
+        int dsp_index;  /* keeping track of the dsp inlets */
+
+
+/*
+ * SDY - we may need to call dsp_setup() in this function
+ */
+
+        if (!ac)
+        {
+                ac = 1;
+                av = &fakearg;
+                SETFLOAT(&fakearg, 0);
+        }
+
+#ifdef PD
+        /*
+         * figure out if we are expr, expr~, or fexpr~
+         */
+        if (!strcmp("expr", s->s_name)) {
+                x = (t_expr *)pd_new(expr_class);
+                SET_EXPR(x);
+        } else if (!strcmp("expr~", s->s_name)) {
+                x = (t_expr *)pd_new(expr_tilde_class);
+                SET_EXPR_TILDE(x);
+        } else if (!strcmp("fexpr~", s->s_name)) {
+                x = (t_expr *)pd_new(fexpr_tilde_class);
+                SET_FEXPR_TILDE(x);
+        } else {
+                post("expr_new: bad object name '%s'");
+                /* assume expr */
+                x = (t_expr *)pd_new(expr_class);
+                SET_EXPR(x);
+        }
+#else /* MSP */
+        /* for now assume an expr~ */
+        x = (t_expr *)pd_new(expr_tilde_class);
+        SET_EXPR_TILDE(x);
+#endif          
+        
+        /*
+         * initialize the newly allocated object
+         */
+        x->exp_proxy = 0;
+        x->exp_nivec = 0;
+        x->exp_nexpr = 0;
+        x->exp_error = 0;
+        for (i = 0; i < MAX_VARS; i++) {
+                x->exp_stack[i] = (struct ex_ex *)0;
+                x->exp_outlet[i] = (t_outlet *)0;
+                x->exp_res[i].ex_type = 0;
+                x->exp_res[i].ex_int = 0;
+                x->exp_p_res[i] = (t_float *)0;
+                x->exp_var[i].ex_type = 0;
+                x->exp_var[i].ex_int = 0;
+                x->exp_p_var[i] = (t_float *)0;
+                x->exp_tmpres[i] = (t_float *)0;
+                x->exp_vsize = 0;
+        }
+        x->exp_f = 0; /* save the control value to be transformed to signal */
+                
+
+        if (expr_donew(x, ac, av))
+        {
+                pd_error(x, "expr: syntax error");
+/*
+SDY the following coredumps why?
+                pd_free(&x->exp_ob.ob_pd);
+*/
+                return (0);
+        }
+
+        ninlet = 1;
+        for (i = 0, eptr = x->exp_var; i < MAX_VARS ; i++, eptr++)
+                if (eptr->ex_type) {
+                        ninlet = i + 1;
+                }
+
+        /*
+         * create the new inlets
+         */
+        for (i = 1, eptr = x->exp_var + 1, dsp_index=1; i<ninlet ; i++, eptr++)
+        {
+                t_exprproxy *p;
+                switch (eptr->ex_type)
+                {
+                case 0:
+                        /* nothing is using this inlet */
+                        if (i < ninlet)
+#ifdef PD
+                                floatinlet_new(&x->exp_ob, &eptr->ex_flt);
+#else /* MSP */
+                                inlet_new(&x->exp_ob, "float");
+#endif
+                        break;
+
+                case ET_II:
+                case ET_FI:
+                        p = exprproxy_new(x, i);
+#ifdef PD
+                        inlet_new(&x->exp_ob, &p->p_pd, &s_float, &s_float);
+#else /* MSP */
+                        inlet_new(&x->exp_ob, "float");
+#endif
+                        break;
+
+                case ET_SI:
+#ifdef PD
+                        symbolinlet_new(&x->exp_ob, (t_symbol **)&eptr->ex_ptr);
+#else /* MSP */
+                        inlet_new(&x->exp_ob, "symbol");
+#endif
+                        break;
+
+                case ET_XI:
+                case ET_VI:
+                        if (!IS_EXPR(x)) {
+                                dsp_index++;
+#ifdef PD
+                                inlet_new(&x->exp_ob, &x->exp_ob.ob_pd,
+                                                        &s_signal, &s_signal);
+#else /* MSP */
+                                inlet_new(&x->exp_ob, "signal");
+#endif
+                                break;
+                        } else
+                                post("expr: internal error expr_new");
+                default:
+                        pd_error(x, "expr: bad type (%lx) inlet = %d\n",
+                                            eptr->ex_type, i + 1, 0, 0, 0);
+                        break;
+                }
+        }
+        if (IS_EXPR(x)) {
+                for (i = 0; i < x->exp_nexpr; i++)
+                        x->exp_outlet[i] = outlet_new(&x->exp_ob, 0);
+        } else {
+                for (i = 0; i < x->exp_nexpr; i++)
+                        x->exp_outlet[i] = outlet_new(&x->exp_ob,
+                                                        gensym("signal"));
+                x->exp_nivec = dsp_index;
+        }
+        /*
+         * for now assume a 64 sample size block but this may change once
+         * expr_dsp is called
+         */
+        x->exp_vsize = 64;
+        for (i = 0; i < x->exp_nexpr; i++) {
+                x->exp_p_res[i] = fts_calloc(x->exp_vsize, sizeof (t_float));
+                x->exp_tmpres[i] = fts_calloc(x->exp_vsize, sizeof (t_float));
+        }
+        for (i = 0; i < MAX_VARS; i++)
+                x->exp_p_var[i] = fts_calloc(x->exp_vsize, sizeof (t_float));
+
+        return (x);
+}
+
+t_int *
+expr_perform(t_int *w)
+{
+        int i, j;
+        t_expr *x = (t_expr *)w[1];
+        struct ex_ex res;
+        int n;
+
+        /* sanity check */
+        if (IS_EXPR(x)) {
+                post("expr_perform: bad x->exp_flags = %d", x->exp_flags);
+                abort();
+        }
+
+        if (x->exp_flags & EF_STOP) {
+                for (i = 0; i < x->exp_nexpr; i++)
+                        memset(x->exp_res[i].ex_vec, 0,
+                                        x->exp_vsize * sizeof (float));
+                return (w + 2);
+        }
+
+        if (IS_EXPR_TILDE(x)) {
+                /*
+                 * if we have only one expression, we can right on
+                 * on the output directly, otherwise we have to copy
+                 * the data because, outputs could be the same buffer as
+                 * inputs
+                 */
+                if ( x->exp_nexpr == 1)
+                        ex_eval(x, x->exp_stack[0], &x->exp_res[0], 0);
+                else {
+                        res.ex_type = ET_VEC;
+                        for (i = 0; i < x->exp_nexpr; i++) {
+                                res.ex_vec = x->exp_tmpres[i];
+                                ex_eval(x, x->exp_stack[i], &res, 0);
+                        }
+                        n = x->exp_vsize * sizeof(t_float);
+                        for (i = 0; i < x->exp_nexpr; i++)
+                                memcpy(x->exp_res[i].ex_vec, x->exp_tmpres[i],
+                                                                        n);
+                }
+                return (w + 2);
+        }
+
+        if (!IS_FEXPR_TILDE(x)) {
+                post("expr_perform: bad x->exp_flags = %d - expecting fexpr",
+                                                                x->exp_flags);
+                return (w + 2);
+        }
+        /*
+         * since the output buffer could be the same as one of the inputs
+         * we need to keep the output in  a different buffer
+         */
+        for (i = 0; i < x->exp_vsize; i++) for (j = 0; j < x->exp_nexpr; j++) {
+                res.ex_type = 0;
+                res.ex_int = 0;
+                ex_eval(x, x->exp_stack[j], &res, i);
+                switch (res.ex_type) {
+                case ET_INT:
+                        x->exp_tmpres[j][i] = (t_float) res.ex_int;
+                        break;
+                case ET_FLT:
+                        x->exp_tmpres[j][i] = res.ex_flt;
+                        break;
+                default:
+                        post("expr_perform: bad result type %d", res.ex_type);
+                }
+        }
+        /*
+         * copy inputs and results to the save buffers
+         * inputs need to be copied first as the output buffer can be
+         * same as an input buffer
+         */
+        n = x->exp_vsize * sizeof(t_float);
+        for (i = 0; i < MAX_VARS; i++)
+                if (x->exp_var[i].ex_type == ET_XI)
+                        memcpy(x->exp_p_var[i], x->exp_var[i].ex_vec, n);
+        for (i = 0; i < x->exp_nexpr; i++) {
+                memcpy(x->exp_p_res[i], x->exp_tmpres[i], n);
+                memcpy(x->exp_res[i].ex_vec, x->exp_tmpres[i], n);
+        }
+        return (w + 2);
+}
+
+static void
+expr_dsp(t_expr *x, t_signal **sp)
+{
+        int i, nv;
+        int newsize;
+
+        x->exp_error = 0;               /* reset all errors */
+        newsize = (x->exp_vsize !=  sp[0]->s_n);
+        x->exp_vsize = sp[0]->s_n;      /* record the vector size */
+        for (i = 0; i < x->exp_nexpr; i++) {
+                x->exp_res[i].ex_type = ET_VEC;
+                x->exp_res[i].ex_vec =  sp[x->exp_nivec + i]->s_vec; 
+        }
+        for (i = 0, nv = 0; i < MAX_VARS; i++)
+                /*
+                 * the first inlet is always a signal
+                 *
+                 * SDY  We are warning the user till this limitation
+                 * is taken away from pd
+                 */
+                if (!i || x->exp_var[i].ex_type == ET_VI ||
+                                        x->exp_var[i].ex_type == ET_XI) {
+                        if (nv >= x->exp_nivec) {
+                          post("expr_dsp int. err nv = %d, x->exp_nive = %d",
+                                                          nv,  x->exp_nivec);
+                          abort();
+                        }
+                        x->exp_var[i].ex_vec  = sp[nv]->s_vec;
+                        nv++;
+                }
+        /* we always have one inlet but we may not use it */
+        if (nv != x->exp_nivec && (nv != 0 ||  x->exp_nivec != 1)) {
+                post("expr_dsp internal error 2 nv = %d, x->exp_nive = %d",
+                                                          nv,  x->exp_nivec);
+                abort();
+        }
+
+        dsp_add(expr_perform, 1, (t_int *) x);
+
+        /*
+         * The buffer are now being allocated for expr~ and fexpr~
+         * because if we have more than one expression we need the
+         * temporary buffers, The save buffers are not really needed
+        if (!IS_FEXPR_TILDE(x))
+                return;
+         */
+        /*
+         * if we have already allocated the buffers and we have a 
+         * new size free all the buffers
+         */
+        if (x->exp_p_res[0]) {
+                if (!newsize)
+                        return;
+                /*
+                 * if new size, reallocate all the previous buffers for fexpr~
+                 */
+                for (i = 0; i < x->exp_nexpr; i++) {
+                        fts_free(x->exp_p_res[i]);
+                        fts_free(x->exp_tmpres[i]);
+                }
+                for (i = 0; i < MAX_VARS; i++)
+                        fts_free(x->exp_p_var[i]);
+
+        }
+        for (i = 0; i < x->exp_nexpr; i++) {
+                x->exp_p_res[i] = fts_calloc(x->exp_vsize, sizeof (t_float));
+                x->exp_tmpres[i] = fts_calloc(x->exp_vsize, sizeof (t_float));
+        }
+        for (i = 0; i < MAX_VARS; i++)
+                x->exp_p_var[i] = fts_calloc(x->exp_vsize, sizeof (t_float));
+}
+
+/*
+ * expr_verbose -- toggle the verbose switch
+ */
+static void
+expr_verbose(t_expr *x)
+{
+        if (x->exp_flags & EF_VERBOSE) {
+                x->exp_flags &= ~EF_VERBOSE;
+                post ("verbose off");
+        } else {
+                x->exp_flags |= EF_VERBOSE;
+                post ("verbose on");
+        }
+}
+
+/*
+ * expr_start -- turn on expr processing for now only used for fexpr~
+ */
+static void
+expr_start(t_expr *x)
+{
+        x->exp_flags &= ~EF_STOP;
+}
+
+/*
+ * expr_stop -- turn on expr processing for now only used for fexpr~
+ */
+static void
+expr_stop(t_expr *x)
+{
+        x->exp_flags |= EF_STOP;
+}
+static void
+fexpr_set_usage(void)
+{
+        post("fexpr~: set val ...");
+        post("fexpr~: set {xy}[#] val ...");
+}
+
+/*
+ * fexpr_tilde_set -- set previous values of the buffers
+ *              set val val ... - sets the first elements of output buffers
+ *              set x val ...   - sets the elements of the first input buffer
+ *              set x# val ...  - sets the elements of the #th input buffers
+ *              set y val ...   - sets the elements of the first output buffer
+ *              set y# val ...  - sets the elements of the #th output buffers
+ */
+static void
+fexpr_tilde_set(t_expr *x, t_symbol *s, int argc, t_atom *argv)
+{
+        t_symbol *sx;
+        int vecno;
+        int i, nargs;
+
+        if (!argc)
+                return;
+        sx = atom_getsymbolarg(0, argc, argv);
+        switch(sx->s_name[0]) {
+        case 'x':
+                if (!sx->s_name[1])
+                        vecno = 0;
+                else {
+                        vecno = atoi(sx->s_name + 1);
+                        if (!vecno) {
+                                post("fexpr~.set: bad set x vector number");
+                                fexpr_set_usage();
+                                return;
+                        }
+                        if (vecno >= MAX_VARS) {
+                                post("fexpr~.set: no more than %d inlets",
+                                                                      MAX_VARS);
+                                return;
+                        }
+                        vecno--;
+                }
+                if (x->exp_var[vecno].ex_type != ET_XI) {
+                        post("fexpr~-set: no signal at inlet %d", vecno + 1);
+                        return;
+                }
+                nargs = argc - 1;
+                if (!nargs) {
+                        post("fexpr~-set: no argument to set");
+                        return;
+                }
+                if (nargs > x->exp_vsize) {
+                   post("fexpr~.set: %d set values larger than vector size(%d)",
+                                                        nargs,  x->exp_vsize);
+                   post("fexpr~.set: only the first %d values will be set",
+                                                                x->exp_vsize);
+                   nargs = x->exp_vsize;
+                }
+                for (i = 0; i < nargs; i++) {
+                        x->exp_p_var[vecno][x->exp_vsize - i - 1] =
+                                        atom_getfloatarg(i + 1, argc, argv);
+                }
+                return;
+        case 'y':
+                if (!sx->s_name[1])
+                        vecno = 0;
+                else {
+                        vecno = atoi(sx->s_name + 1);
+                        if (!vecno) {
+                                post("fexpr~.set: bad set y vector number");
+                                fexpr_set_usage();
+                                return;
+                        }
+                        vecno--;
+                }
+                if (vecno >= x->exp_nexpr) {
+                        post("fexpr~.set: only %d outlets", x->exp_nexpr);
+                        return;
+                }
+                nargs = argc - 1;
+                if (!nargs) {
+                        post("fexpr~-set: no argument to set");
+                        return;
+                }
+                if (nargs > x->exp_vsize) {
+                   post("fexpr~-set: %d set values larger than vector size(%d)",
+                                                        nargs,  x->exp_vsize);
+                   post("fexpr~.set: only the first %d values will be set",
+                                                                x->exp_vsize);
+                   nargs = x->exp_vsize;
+                }
+                for (i = 0; i < nargs; i++) {
+                        x->exp_p_res[vecno][x->exp_vsize - i - 1] =
+                                        atom_getfloatarg(i + 1, argc, argv);
+                }
+                return;
+        case 0:
+                if (argc >  x->exp_nexpr) {
+                        post("fexpr~.set: only %d outlets available",
+                                                                x->exp_nexpr);
+                        post("fexpr~.set: the extra set values are ignored");
+                }
+                for (i = 0; i < x->exp_nexpr && i < argc; i++)
+                        x->exp_p_res[i][x->exp_vsize - 1] =
+                                        atom_getfloatarg(i, argc, argv);
+                return;
+        default:
+                fexpr_set_usage();
+                return;
+        }
+        return;
+}
+
+/*
+ * fexpr_tilde_clear - clear the past buffers
+ */
+static void
+fexpr_tilde_clear(t_expr *x, t_symbol *s, int argc, t_atom *argv)
+{
+        t_symbol *sx;
+        int vecno;
+        int i, nargs;
+
+        /*
+         *  if no arguement clear all input and output buffers
+         */
+        if (!argc) {
+                for (i = 0; i < x->exp_nexpr; i++)
+                        memset(x->exp_p_res[i], 0, x->exp_vsize*sizeof(float));
+                for (i = 0; i < MAX_VARS; i++)
+                        if (x->exp_var[i].ex_type == ET_XI)
+                                memset(x->exp_p_var[i], 0,
+                                                x->exp_vsize*sizeof(float));
+                return;
+        }
+        if (argc > 1) {
+                post("fexpr~ usage: 'clear' or 'clear {xy}[#]'");
+                return;
+        }
+
+        sx = atom_getsymbolarg(0, argc, argv);
+        switch(sx->s_name[0]) {
+        case 'x':
+                if (!sx->s_name[1])
+                        vecno = 0;
+                else {
+                        vecno = atoi(sx->s_name + 1);
+                        if (!vecno) {
+                                post("fexpr~.clear: bad clear x vector number");
+                                return;
+                        }
+                        if (vecno >= MAX_VARS) {
+                                post("fexpr~.clear: no more than %d inlets",
+                                                                      MAX_VARS);
+                                return;
+                        }
+                        vecno--;
+                }
+                if (x->exp_var[vecno].ex_type != ET_XI) {
+                        post("fexpr~-clear: no signal at inlet %d", vecno + 1);
+                        return;
+                }
+                memset(x->exp_p_var[vecno], 0, x->exp_vsize*sizeof(float));
+                return;
+        case 'y':
+                if (!sx->s_name[1])
+                        vecno = 0;
+                else {
+                        vecno = atoi(sx->s_name + 1);
+                        if (!vecno) {
+                                post("fexpr~.clear: bad clear y vector number");
+                                return;
+                        }
+                        vecno--;
+                }
+                if (vecno >= x->exp_nexpr) {
+                        post("fexpr~.clear: only %d outlets", x->exp_nexpr);
+                        return;
+                }
+                memset(x->exp_p_res[vecno], 0, x->exp_vsize*sizeof(float));
+                return;
+                return;
+        default:
+                post("fexpr~ usage: 'clear' or 'clear {xy}[#]'");
+                return;
+        }
+        return;
+}
+
+#ifdef PD
+
+void
+expr_setup(void)
+{
+        /*
+         * expr initialization
+         */
+        expr_class = class_new(gensym("expr"), (t_newmethod)expr_new,
+            (t_method)expr_ff, sizeof(t_expr), 0, A_GIMME, 0);
+        class_addlist(expr_class, expr_list);
+        exprproxy_class = class_new(gensym("exprproxy"), 0,
+                                        0, sizeof(t_exprproxy), CLASS_PD, 0);
+        class_addfloat(exprproxy_class, exprproxy_float);
+
+        /*
+         * expr~ initialization
+         */
+        expr_tilde_class = class_new(gensym("expr~"), (t_newmethod)expr_new,
+            (t_method)expr_ff, sizeof(t_expr), 0, A_GIMME, 0);
+        class_addmethod(expr_tilde_class, nullfn, gensym("signal"), 0);
+        CLASS_MAINSIGNALIN(expr_tilde_class, t_expr, exp_f);
+        class_addmethod(expr_tilde_class,(t_method)expr_dsp, gensym("dsp"), 0);
+        class_sethelpsymbol(expr_tilde_class, gensym("expr"));
+        /*
+         * fexpr~ initialization
+         */
+        fexpr_tilde_class = class_new(gensym("fexpr~"), (t_newmethod)expr_new,
+            (t_method)expr_ff, sizeof(t_expr), 0, A_GIMME, 0);
+        class_addmethod(fexpr_tilde_class, nullfn, gensym("signal"), 0);
+        class_addmethod(fexpr_tilde_class,(t_method)expr_start,
+                                                        gensym("start"), 0);
+        class_addmethod(fexpr_tilde_class,(t_method)expr_stop,
+                                                        gensym("stop"), 0);
+
+        class_addmethod(fexpr_tilde_class,(t_method)expr_dsp,gensym("dsp"), 0);
+        class_addmethod(fexpr_tilde_class, (t_method)fexpr_tilde_set,
+                        gensym("set"), A_GIMME, 0);
+        class_addmethod(fexpr_tilde_class, (t_method)fexpr_tilde_clear,
+                        gensym("clear"), A_GIMME, 0);
+        class_addmethod(fexpr_tilde_class,(t_method)expr_verbose,
+                                                        gensym("verbose"), 0);
+        class_sethelpsymbol(fexpr_tilde_class, gensym("expr"));
+
+
+
+        post("expr, expr~, fexpr~ version %s under GNU General Public License ", exp_version);
+
+}
+
+void
+expr_tilde_setup(void)
+{
+        expr_setup();
+}
+
+void
+fexpr_tilde_setup(void)
+{
+        expr_setup();
+}
+#else /* MSP */
+void
+main(void)
+{
+        setup((t_messlist **)&expr_tilde_class, (method)Nexpr_new,
+                (method)expr_ff, (short)sizeof(t_expr), 0L, A_GIMME, 0);
+        addmess((method)expr_dsp, "dsp", A_CANT, 0); // dsp method
+        dsp_initclass();
+}
+#endif
+
+
+/* -- the following functions use Pd internals and so are in the "if" file. */
+
+
+int
+ex_getsym(char *p, fts_symbol_t *s)
+{
+        *s = gensym(p);
+        return (0);
+}
+
+const char *
+ex_symname(fts_symbol_t s)
+{
+        return (fts_symbol_name(s));
+}
+
+/*
+ * max_ex_tab -- evaluate this table access
+ *               eptr is the name of the table and arg is the index we
+ *               have to put the result in optr
+ *               return 1 on error and 0 otherwise
+ *
+ * Arguments:
+ *  the expr object
+ *  table 
+ *  the argument 
+ *  the result pointer 
+ */
+int
+max_ex_tab(struct expr *expr, fts_symbol_t s, struct ex_ex *arg,
+    struct ex_ex *optr)
+{
+#ifdef PD
+        t_garray *garray;
+        int size, indx;
+        t_float *vec;
+
+        if (!s || !(garray = (t_garray *)pd_findbyclass(s, garray_class)) ||
+            !garray_getfloatarray(garray, &size, &vec))
+        {
+                optr->ex_type = ET_FLT;
+                optr->ex_flt = 0;
+                pd_error(expr, "no such table '%s'", s->s_name);
+                return (1);
+        }
+        optr->ex_type = ET_FLT;
+
+        switch (arg->ex_type) {
+        case ET_INT:
+                indx = arg->ex_int;
+                break;
+        case ET_FLT:
+                /* strange interpolation code deleted here -msp */
+                indx = arg->ex_flt;
+                break;
+
+        default:        /* do something with strings */
+                pd_error(expr, "expr: bad argument for table '%s'\n", fts_symbol_name(s));
+                indx = 0;
+        }
+        if (indx < 0) indx = 0;
+        else if (indx >= size) indx = size - 1;
+        optr->ex_flt = vec[indx];
+#else /* MSP */
+        /*
+         * table lookup not done for MSP yet
+         */
+        post("max_ex_tab: not complete for MSP yet!");
+        optr->ex_type = ET_FLT;
+        optr->ex_flt = 0;
+#endif  
+        return (0);
+}
+
+int
+max_ex_var(struct expr *expr, fts_symbol_t var, struct ex_ex *optr)
+{
+        optr->ex_type = ET_FLT;
+        if (value_getfloat(var, &(optr->ex_flt))) {
+                optr->ex_type = ET_FLT;
+                optr->ex_flt = 0;
+                pd_error(expr, "no such var '%s'", var->s_name);
+                return (1);
+        }
+        return (0);
+}
+
+#ifdef PD /* this goes to the end of this file as the following functions
+           * should be defined in the expr object in MSP
+           */
+#define ISTABLE(sym, garray, size, vec)                               \
+if (!sym || !(garray = (t_garray *)pd_findbyclass(sym, garray_class)) || \
+                !garray_getfloatarray(garray, &size, &vec))  {          \
+        optr->ex_type = ET_FLT;                                         \
+        optr->ex_int = 0;                                               \
+        error("no such table '%s'", sym->s_name);                       \
+        return;                                                         \
+}
+
+/*
+ * ex_size -- find the size of a table
+ */
+void
+ex_size(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        t_symbol *s;
+        t_garray *garray;
+        int size;
+        t_float *vec;
+
+        if (argv->ex_type != ET_SYM)
+        {
+                post("expr: size: need a table name\n");
+                optr->ex_type = ET_INT;
+                optr->ex_int = 0;
+                return;
+        }
+
+        s = (fts_symbol_t ) argv->ex_ptr;
+
+        ISTABLE(s, garray, size, vec);
+
+        optr->ex_type = ET_INT;
+        optr->ex_int = size;
+}
+
+/*
+ * ex_sum -- calculate the sum of all elements of a table
+ */
+
+void
+ex_sum(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        t_symbol *s;
+        t_garray *garray;
+        int size;
+        t_float *vec, sum;
+        int indx;
+
+        if (argv->ex_type != ET_SYM)
+        {
+                post("expr: sum: need a table name\n");
+                optr->ex_type = ET_INT;
+                optr->ex_int = 0;
+                return;
+        }
+
+        s = (fts_symbol_t ) argv->ex_ptr;
+
+        ISTABLE(s, garray, size, vec);
+
+        for (indx = 0, sum = 0; indx < size; indx++)
+                sum += vec[indx];
+
+        optr->ex_type = ET_FLT;
+        optr->ex_flt = sum;
+}
+
+
+/*
+ * ex_Sum -- calculate the sum of table with the given boundries
+ */
+
+void
+ex_Sum(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+        t_symbol *s;
+        t_garray *garray;
+        int size;
+        t_float *vec, sum;
+        int indx, n1, n2;
+
+        if (argv->ex_type != ET_SYM)
+        {
+                post("expr: sum: need a table name\n");
+                optr->ex_type = ET_INT;
+                optr->ex_int = 0;
+                return;
+        }
+
+        s = (fts_symbol_t ) argv->ex_ptr;
+
+        ISTABLE(s, garray, size, vec);
+
+        if (argv->ex_type != ET_INT || argv[1].ex_type != ET_INT)
+        {
+                post("expr: Sum: boundries have to be fix values\n");
+                optr->ex_type = ET_INT;
+                optr->ex_int = 0;
+                return;
+        }
+        n1 = argv->ex_int;
+        n2 = argv[1].ex_int;
+
+        for (indx = n1, sum = 0; indx < n2; indx++)
+                if (indx >= 0 && indx < size)
+                        sum += vec[indx];
+
+        optr->ex_type = ET_FLT;
+        optr->ex_flt = sum;
+}
+
+/*
+ * ex_avg -- calculate the avarage of a table
+ */
+
+void
+ex_avg(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+/* SDY - look into this function */
+#if 0
+        fts_symbol_t s;
+        fts_integer_vector_t *tw = 0;
+
+        if (argv->ex_type != ET_SYM)
+        {
+                post("expr: avg: need a table name\n");
+                optr->ex_type = ET_INT;
+                optr->ex_int = 0;
+        }
+
+        s = (fts_symbol_t ) argv->ex_ptr;
+
+        tw = table_integer_vector_get_by_name(s);
+
+        if (tw)
+        {
+                optr->ex_type = ET_INT;
+
+                if (! fts_integer_vector_get_size(tw))
+                        optr->ex_int = 0;
+                else
+                        optr->ex_int = fts_integer_vector_get_sum(tw) / fts_integer_vector_get_size(tw);
+        }
+        else
+        {
+                optr->ex_type = ET_INT;
+                optr->ex_int = 0;
+                post("expr: avg: no such table %s\n", fts_symbol_name(s));
+        }
+#endif
+}
+
+
+/*
+ * ex_Avg -- calculate the avarage of table with the given boundries
+ */
+
+void
+ex_Avg(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+/* SDY - look into this function */
+#if 0
+        fts_symbol_t s;
+        fts_integer_vector_t *tw = 0;
+
+        if (argv->ex_type != ET_SYM)
+        {
+                post("expr: Avg: need a table name\n");
+                optr->ex_type = ET_INT;
+                optr->ex_int = 0;
+        }
+
+        s = (fts_symbol_t ) (argv++)->ex_ptr;
+
+        tw = table_integer_vector_get_by_name(s);
+
+        if (! tw)
+        {
+                optr->ex_type = ET_INT;
+                optr->ex_int = 0;
+                post("expr: Avg: no such table %s\n", fts_symbol_name(s));
+                return;
+        }
+
+        if (argv->ex_type != ET_INT || argv[1].ex_type != ET_INT)
+        {
+                post("expr: Avg: boundries have to be fix values\n");
+                optr->ex_type = ET_INT;
+                optr->ex_int = 0;
+                return;
+        }
+
+        optr->ex_type = ET_INT;
+
+        if (argv[1].ex_int - argv->ex_int <= 0)
+                optr->ex_int = 0;
+        else
+                optr->ex_int = (fts_integer_vector_get_sub_sum(tw, argv->ex_int, argv[1].ex_int) /
+                    (argv[1].ex_int - argv->ex_int));
+#endif
+}
+
+/*
+ * ex_store -- store a value in a table
+ *             if the index is greater the size of the table,
+ *             we will make a modulo the size of the table
+ */
+
+void
+ex_store(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+/* SDY - look into this function */
+#if 0
+        fts_symbol_t s;
+        fts_integer_vector_t *tw = 0;
+
+        if (argv->ex_type != ET_SYM)
+        {
+                post("expr: store: need a table name\n");
+        }
+
+        s = (fts_symbol_t ) (argv++)->ex_ptr;
+
+        tw = table_integer_vector_get_by_name(s);
+
+        if (! tw)
+        {
+                optr->ex_type = ET_INT;
+                optr->ex_int = 0;
+                post("expr: store: no such table %s\n", fts_symbol_name(s));
+                return;
+        }
+
+        if (argv->ex_type != ET_INT || argv[1].ex_type != ET_INT)
+        {
+                post("expr: store: arguments have to be integer\n");
+                optr->ex_type = ET_INT;
+                optr->ex_int = 0;
+        }
+
+        fts_integer_vector_set_element(tw, argv->ex_int < 0 ? 0 : argv->ex_int % fts_integer_vector_get_size(tw), argv[1].ex_int);
+        *optr = argv[1];
+#endif
+}
+
+#else /* MSP */
+
+void 
+pd_error(void *object, char *fmt, ...)
+{
+    va_list ap;
+    t_int arg[8];
+    int i;
+    static int saidit = 0;
+    va_start(ap, fmt);
+/* SDY
+    vsprintf(error_string, fmt, ap);
+ */ post(fmt, ap);
+        va_end(ap);
+/* SDY
+    fprintf(stderr, "error: %s\n", error_string);
+    error_object = object;
+*/
+    if (!saidit)
+    {
+        post("... you might be able to track this down from the Find menu.");
+        saidit = 1;
+    }
+}
+#endif
diff --git a/desiredata/extra/fiddle~/fiddle~.c b/desiredata/extra/fiddle~/fiddle~.c
new file mode 100644
index 00000000..d959b00f
--- /dev/null
+++ b/desiredata/extra/fiddle~/fiddle~.c
@@ -0,0 +1,1845 @@
+/* Copyright (c) 1997-1999 Miller Puckette and Ted Apel.
+* For information on usage and redistribution, and for a DISCLAIMER OF ALL
+* WARRANTIES, see the file, "LICENSE.txt," in this distribution.  */
+
+/*
+ * Fiddle is a pitch tracker hardwired to have hop size ("H") equal to
+ * half its window size ("N").
+ *
+ * This version should compile for Max "0.26," JMAX, Pd, or Max/MSP.
+ *
+ * The "lastanalysis" field holds the shifted FT of the previous H
+ * samples.  The buffer contains in effect points 1/2,  3/2, ..., (N-1)/2
+ * of the DTFT of a real vector of length N, half of whose points are zero,
+ * i.e.,  only the first H points are used.  Put another way, we get the
+ * the odd-numbered points of the FFT of the H points, zero padded to 4*H in
+ * length. The integer points 0, 1, ..., H-1
+ * are found by interpolating these others,  using the fact that the
+ * half-integer points are band-limited (they only have positive frequencies.)
+ * To facilitate the interpolation the "lastanalysis" buffer contains
+ * FILTSIZE extra points (1/2-FILTSIZE, ...,  -1/2) at the beginning and
+ * FILTSIZE again at the end ((N+1)/2, ..., FILTSIZE+(N-1)/2).  The buffer
+ * therefore has N+4*FILTSIZE floating-point numbers in it.
+ *
+ * after doing this I found out that you can just do a real FFT
+ * of the H new points, zero-padded to contain N points, and using a similar
+ * but simpler interpolation scheme you can still get 2N points of the DTFT
+ * of the N points.  Jean Laroche is a big fat hen.
+ *
+ */
+
+#ifdef NT
+#define flog log
+#define fexp exp
+#define fsqrt sqrt
+#pragma warning (disable: 4305 4244)
+#else
+#define flog log
+#define fexp exp
+#define fsqrt sqrt
+#endif
+
+char fiddle_version[] = "fiddle version 1.1 TEST4";
+
+#ifdef JMAX
+#include "fts.h"
+#include <stdio.h>
+#include <stdlib.h>
+typedef float t_float;
+typedef float t_floatarg;
+typedef fts_symbol_t t_symbol;
+
+static void *getbytes(size_t nbytes)
+{
+    void *ret;
+    if (nbytes < 1) nbytes = 1;
+    ret = (void *)malloc(nbytes);
+    return (ret);
+}
+
+static void *resizebytes(void *old, size_t oldsize, size_t newsize)
+{
+    void *ret;
+    if (newsize < 1) newsize = 1;
+    ret = (void *)realloc((char *)old, newsize);
+    return (ret);
+}
+
+static void freebytes(void *fatso, size_t nbytes)
+{
+    free(fatso);
+}
+
+#define CLASSNAME "fiddle"
+
+#define OUTLETpower 5
+#define OUTLETmicropitch1 4
+#define OUTLETmicropitch2 3
+#define OUTLETmicropitch3 2
+#define OUTLETattack 1
+#define OUTLETpitch 0
+
+static fts_symbol_t *dsp_symbol = 0;
+#define error post
+
+#endif /* FTS */
+
+#ifdef MAX26
+#define t_floatarg double
+#include "m_extern.h"
+#include "d_graph.h"
+#include "d_ugen.h"
+#endif /* MAX26 */
+
+#ifdef PD
+#include "m_pd.h"
+#endif /* PD */
+
+#ifdef MSP
+#define flog log
+#define fexp exp
+#define fsqrt sqrt
+#endif /* MSP */
+
+#ifdef MSP
+#define t_floatarg double
+#include "ext.h"
+#include "z_dsp.h"
+#include "fft_mayer.proto.h"
+
+#endif /* MSP */
+
+#include <math.h>
+
+
+#define MINBIN 3
+#define DEFAMPLO 40
+#define DEFAMPHI 50
+#define DEFATTACKTIME 100
+#define DEFATTACKTHRESH 10
+#define DEFVIBTIME 50
+#define DEFVIBDEPTH 0.5
+#define GLISS 0.7f
+#define DBFUDGE 30.8f
+#define MINFREQINBINS 5     /* minimum frequency in bins for reliable output */
+
+#define MAXNPITCH 3
+#define MAXHIST 3                   /* find N hottest peaks in histogram */
+
+#define MAXPOINTS 8192
+#define MINPOINTS 128
+#define DEFAULTPOINTS 1024
+
+#define HISTORY 20
+#define MAXPEAK 100             /* maximum number of peaks */
+#define DEFNPEAK 20             /* default number of peaks */
+
+#define MAXNPEAK (MAXLOWPEAK + MAXSTRONGPEAK)
+#define MINBW (0.03f)                   /* consider BW >= 0.03 FFT bins */
+
+#define BINPEROCT 48                    /* bins per octave */
+#define BPERO_OVER_LOG2 69.24936196f    /* BINSPEROCT/log(2) */
+#define FACTORTOBINS (float)(4/0.0145453)       /* 4 / (pow(2.,1/48.) - 1) */
+#define BINGUARD 10                     /* extra bins to throw in front */
+#define PARTIALDEVIANCE 0.023f          /* acceptable partial detuning in % */
+#define LOGTODB 4.34294481903f          /* 20/log(10) */
+
+#define KNOCKTHRESH 10.f     /* don't know how to describe this */
+
+
+static float sigfiddle_partialonset[] =
+{
+0,
+48,
+76.0782000346154967102,
+96,
+111.45254855459339269887,
+124.07820003461549671089,
+134.75303625876499715823,
+144,
+152.15640006923099342109,
+159.45254855459339269887,
+166.05271769459026829915,
+172.07820003461549671088,
+177.62110647077242370064,
+182.75303625876499715892,
+187.53074858920888940907,
+192,
+};
+
+#define NPARTIALONSET ((int)(sizeof(sigfiddle_partialonset)/sizeof(float)))
+
+static int sigfiddle_intpartialonset[] =
+{
+0,
+48,
+76,
+96,
+111,
+124,
+135,
+144,
+152,
+159,
+166,
+172,
+178,
+183,
+188,
+192,
+};
+
+/* these coefficients, which come from the "upsamp" subdirectory,
+are a filter kernel for upsampling by a factor of two, assuming
+the sound to be upsampled has no energy above half the Nyquist, i.e.,
+that it's already 2x oversampled compared to the theoretically possible
+sample rate.  I got these by trial and error. */
+
+#define FILT1 ((float)(.5 * 1.227054))
+#define FILT2 ((float)(.5 * -0.302385))
+#define FILT3 ((float)(.5 * 0.095326))
+#define FILT4 ((float)(.5 * -0.022748))
+#define FILT5 ((float)(.5 * 0.002533))
+#define FILTSIZE 5
+
+typedef struct peakout      /* a peak for output */
+{
+    float po_freq;                  /* frequency in hz */
+    float po_amp;                   /* amplitude */
+} t_peakout;
+
+typedef struct peak         /* a peak for analysis */
+{
+    float p_freq;                   /* frequency in bins */
+    float p_width;                  /* peak width in bins */
+    float p_pow;                    /* peak power */
+    float p_loudness;               /* 4th root of power */
+    float *p_fp;                    /* pointer back to spectrum */
+} t_peak;
+
+typedef struct histopeak
+{
+    float h_pitch;                  /* estimated pitch */
+    float h_value;                  /* value of peak */
+    float h_loud;                   /* combined strength of found partials */
+    int h_index;                    /* index of bin holding peak */
+    int h_used;                     /* true if an x_hist entry points here */
+} t_histopeak;
+
+typedef struct pitchhist            /* struct for keeping history by pitch */
+{
+    float h_pitch;                  /* pitch to output */
+    float h_amps[HISTORY];          /* past amplitudes */
+    float h_pitches[HISTORY];       /* past pitches */
+    float h_noted;                  /* last pitch output */
+    int h_age;                      /* number of frames pitch has been there */
+    t_histopeak *h_wherefrom;       /* new histogram peak to incorporate */
+    void *h_outlet;
+} t_pitchhist;
+
+typedef struct sigfiddle                    /* instance struct */
+{
+#ifdef JMAX
+    fts_object_t x_h;               /* object header */
+    fts_alarm_t x_clock;            /* callback for timeouts */
+#endif
+#ifdef MAX26
+    t_head x_h;                     /* header for tilde objects */
+    t_sig *x_io[IN1+OUT0];          /* number of signal inputs and outputs */
+    void *x_clock;                  /* a "clock" object */
+#endif
+#ifdef PD
+    t_object x_ob;                  /* object header */
+    t_clock *x_clock;               /* callback for timeouts */
+#endif
+#ifdef MSP
+        t_pxobject x_obj;
+        void *x_clock;
+        long x_downsample;              /* downsample feature because of
+                                         MSP's large sig vector sizes */
+#endif
+    float *x_inbuf;                 /* buffer to analyze, npoints/2 elems */
+    float *x_lastanalysis;          /* FT of last buffer (see main comment) */
+    float *x_spiral;                /* 1/4-wave complex exponential */
+    t_peakout *x_peakbuf;           /* spectral peaks for output */
+    int x_npeakout;                 /* number of spectral peaks to output */
+    int x_npeakanal;                /* number of spectral peaks to analyze */
+    int x_phase;                    /* number of points since last output */
+    int x_histphase;                /* phase into amplitude history vector */
+    int x_hop;                      /* period of output, npoints/2 */
+    float x_sr;                     /* sample rate */
+    t_pitchhist x_hist[MAXNPITCH];  /* history of current pitches */
+    int x_nprint;                   /* how many periods to print */
+    int x_npitch;                   /* number of simultaneous pitches */
+    float x_dbs[HISTORY];           /* DB history, indexed by "histphase" */
+    float x_peaked;                 /* peak since last attack */
+    int x_dbage;                    /* number of bins DB has met threshold */
+    int x_auto;                     /* true if generating continuous output */
+/* parameters */
+    float x_amplo;
+    float x_amphi;
+    int x_attacktime;
+    int x_attackbins;
+    float x_attackthresh;
+    int x_vibtime;
+    int x_vibbins;
+    float x_vibdepth;
+    float x_npartial;
+/* outlets & clock */
+    void *x_envout;
+    int x_attackvalue;
+    void *x_attackout;
+    void *x_noteout;
+    void *x_peakout;
+} t_sigfiddle;
+
+#if CHECKER
+float fiddle_checker[1024];
+#endif
+
+#ifdef MSP
+/* Mac compiler requires prototypes for everything */
+
+int sigfiddle_ilog2(int n);
+float fiddle_mtof(float f);
+float fiddle_ftom(float f);
+void sigfiddle_doit(t_sigfiddle *x);
+void sigfiddle_debug(t_sigfiddle *x);
+void sigfiddle_print(t_sigfiddle *x);
+void sigfiddle_assist(t_sigfiddle *x, void *b, long m, long a, char *s);
+void sigfiddle_amprange(t_sigfiddle *x, double amplo,  double amphi);
+void sigfiddle_reattack(t_sigfiddle *x, t_floatarg attacktime, t_floatarg
+attackthresh);
+void sigfiddle_vibrato(t_sigfiddle *x, t_floatarg vibtime, t_floatarg
+vibdepth);
+void sigfiddle_npartial(t_sigfiddle *x, double npartial);
+void sigfiddle_auto(t_sigfiddle *x, t_floatarg f);
+void sigfiddle_setnpoints(t_sigfiddle *x, t_floatarg f);
+int sigfiddle_doinit(t_sigfiddle *x, long npoints, long npitch, long
+npeakanal, long npeakout);
+static t_int *fiddle_perform(t_int *w);
+void sigfiddle_dsp(t_sigfiddle *x, t_signal **sp);
+void sigfiddle_tick(t_sigfiddle *x);
+void sigfiddle_bang(t_sigfiddle *x);
+void sigfiddle_ff(t_sigfiddle *x);
+void *sigfiddle_new(long npoints, long npitch,
+    long npeakanal, long npeakout);
+void msp_fft(float *buf, long np, long inv);
+float msp_ffttemp[MAXPOINTS*2];
+int errno;
+#endif
+
+int sigfiddle_ilog2(int n)
+{
+    int ret = -1;
+    while (n)
+    {
+        n >>= 1;
+        ret++;
+    }
+    return (ret);
+}
+
+float fiddle_mtof(float f)
+{
+        return (8.17579891564 * exp(.0577622650 * f));
+}
+
+float fiddle_ftom(float f)
+{
+        return (17.3123405046 * log(.12231220585 * f));
+}
+#define ftom fiddle_ftom
+#define mtof fiddle_mtof
+
+void sigfiddle_doit(t_sigfiddle *x)
+{
+#ifdef MSP
+        /* prevents interrupt-level stack overflow crash with Netscape. */
+    static float spect1[4*MAXPOINTS];
+    static float spect2[MAXPOINTS + 4*FILTSIZE];
+#else
+    float spect1[4*MAXPOINTS];
+    float spect2[MAXPOINTS + 4*FILTSIZE];
+#endif
+#if CHECKER
+    float checker3[4*MAXPOINTS];
+#endif
+
+    t_peak peaklist[MAXPEAK + 1], *pk1;
+    t_peakout *pk2;
+    t_histopeak histvec[MAXHIST], *hp1;
+    int i, j, k, hop = x->x_hop, n = 2*hop, npeak, npitch,
+        logn = sigfiddle_ilog2(n), newphase, oldphase;
+    float *fp, *fp1, *fp2, *fp3, total_power, total_loudness, total_db;
+    float maxbin = BINPEROCT * (logn-2),  *histogram = spect2 + BINGUARD;
+    t_pitchhist *phist;
+    float hzperbin = x->x_sr / (2.0f * n);
+    int npeakout = x->x_npeakout, npeakanal = x->x_npeakanal;
+    int npeaktot = (npeakout > npeakanal ? npeakout : npeakanal);
+
+    oldphase = x->x_histphase;
+    newphase = x->x_histphase + 1;
+    if (newphase == HISTORY) newphase = 0;
+    x->x_histphase = newphase;
+
+        /*
+         * multiply the H points by a 1/4-wave complex exponential,
+         * and take FFT of the result.
+         */
+    for (i = 0, fp1 = x->x_inbuf, fp2 = x->x_spiral, fp3 = spect1;
+        i < hop; i++, fp1++, fp2 += 2, fp3 += 2)
+            fp3[0] = fp1[0] * fp2[0], fp3[1] = fp1[0] * fp2[1];
+
+#ifdef MAX26
+    fft(spect1, hop, 0);
+#endif
+#ifdef PD
+    pd_fft(spect1, hop, 0);
+#endif
+#ifdef JMAX
+    fts_cfft_inplc((complex *)spect1, hop);
+#endif
+#ifdef MSP
+        msp_fft(spect1,hop,0);
+#endif
+        /*
+         * now redistribute the points to get in effect the odd-numbered
+         * points of the FFT of the H points, zero padded to 4*H in length.
+         */
+    for (i = 0, fp1 = spect1, fp2 = spect2 + (2*FILTSIZE);
+        i < (hop>>1); i++, fp1 += 2, fp2 += 4)
+            fp2[0] = fp1[0], fp2[1] = fp1[1];
+    for (i = 0, fp1 = spect1 + n - 2, fp2 = spect2 + (2*FILTSIZE+2);
+        i < (hop>>1); i++, fp1 -= 2, fp2 += 4)
+            fp2[0] = fp1[0], fp2[1] = -fp1[1];
+    for (i = 0, fp1 = spect2 + (2*FILTSIZE), fp2 = spect2 + (2*FILTSIZE-2);
+        i<FILTSIZE; i++, fp1+=2, fp2-=2)
+            fp2[0] = fp1[0],  fp2[1] = -fp1[1];
+    for (i = 0, fp1 = spect2 + (2*FILTSIZE+n-2), fp2 = spect2 + (2*FILTSIZE+n);
+        i<FILTSIZE; i++, fp1-=2, fp2+=2)
+            fp2[0] = fp1[0],  fp2[1] = -fp1[1];
+#if 0
+    {
+        fp = spect2 + 2*FILTSIZE;
+        post("x1 re %12.4f %12.4f %12.4f %12.4f %12.4f",
+            fp[0], fp[2], fp[4], fp[6], fp[8]);
+        post("x1 im %12.4f %12.4f %12.4f %12.4f %12.4f",
+            fp[1], fp[3], fp[5], fp[7], fp[9]);
+    }
+#endif
+        /* spect2 is now prepared; now combine spect2 and lastanalysis into
+         * spect1.  Odd-numbered points of spect1 are the points of "last"
+         * plus (-i, i, -i, ...) times spect1.  Even-numbered points are
+         * the interpolated points of "last" plus (1, -1, 1, ...) times the
+         * interpolated points of spect1.
+         *
+         * To interpolate, take FILT1 exp(-pi/4) times
+         * the previous point,  FILT2*exp(-3*pi/4) times 3 bins before,
+         * etc,  and FILT1 exp(pi/4), FILT2 exp(3pi/4), etc., to weight
+         * the +1, +3, etc., points.
+         *
+         * In this calculation,  we take (1, i, -1, -i, 1) times the
+         * -9, -7, ..., -1 points, and (i, -1, -i, 1, i) times the 1, 3,..., 9
+         * points of the OLD spectrum, alternately adding and subtracting
+         * the new spectrum to the old; then we multiply the whole thing
+         * by exp(-i pi/4).
+         */
+    for (i = 0, fp1 = spect1, fp2 = x->x_lastanalysis + 2*FILTSIZE,
+        fp3 = spect2 + 2*FILTSIZE;
+            i < (hop>>1); i++)
+    {
+        float re,  im;
+
+        re= FILT1 * ( fp2[ -2] -fp2[ 1]  +fp3[ -2] -fp3[ 1]) +
+            FILT2 * ( fp2[ -3] -fp2[ 2]  +fp3[ -3] -fp3[ 2]) +
+            FILT3 * (-fp2[ -6] +fp2[ 5]  -fp3[ -6] +fp3[ 5]) +
+            FILT4 * (-fp2[ -7] +fp2[ 6]  -fp3[ -7] +fp3[ 6]) +
+            FILT5 * ( fp2[-10] -fp2[ 9]  +fp3[-10] -fp3[ 9]);
+
+        im= FILT1 * ( fp2[ -1] +fp2[ 0]  +fp3[ -1] +fp3[ 0]) +
+            FILT2 * (-fp2[ -4] -fp2[ 3]  -fp3[ -4] -fp3[ 3]) +
+            FILT3 * (-fp2[ -5] -fp2[ 4]  -fp3[ -5] -fp3[ 4]) +
+            FILT4 * ( fp2[ -8] +fp2[ 7]  +fp3[ -8] +fp3[ 7]) +
+            FILT5 * ( fp2[ -9] +fp2[ 8]  +fp3[ -9] +fp3[ 8]);
+
+        fp1[0] = 0.7071f * (re + im);
+        fp1[1] = 0.7071f * (im - re);
+        fp1[4] = fp2[0] + fp3[1];
+        fp1[5] = fp2[1] - fp3[0];
+        
+        fp1 += 8, fp2 += 2, fp3 += 2;
+        re= FILT1 * ( fp2[ -2] -fp2[ 1]  -fp3[ -2] +fp3[ 1]) +
+            FILT2 * ( fp2[ -3] -fp2[ 2]  -fp3[ -3] +fp3[ 2]) +
+            FILT3 * (-fp2[ -6] +fp2[ 5]  +fp3[ -6] -fp3[ 5]) +
+            FILT4 * (-fp2[ -7] +fp2[ 6]  +fp3[ -7] -fp3[ 6]) +
+            FILT5 * ( fp2[-10] -fp2[ 9]  -fp3[-10] +fp3[ 9]);
+
+        im= FILT1 * ( fp2[ -1] +fp2[ 0]  -fp3[ -1] -fp3[ 0]) +
+            FILT2 * (-fp2[ -4] -fp2[ 3]  +fp3[ -4] +fp3[ 3]) +
+            FILT3 * (-fp2[ -5] -fp2[ 4]  +fp3[ -5] +fp3[ 4]) +
+            FILT4 * ( fp2[ -8] +fp2[ 7]  -fp3[ -8] -fp3[ 7]) +
+            FILT5 * ( fp2[ -9] +fp2[ 8]  -fp3[ -9] -fp3[ 8]);
+
+        fp1[0] = 0.7071f * (re + im);
+        fp1[1] = 0.7071f * (im - re);
+        fp1[4] = fp2[0] - fp3[1];
+        fp1[5] = fp2[1] + fp3[0];
+        
+        fp1 += 8, fp2 += 2, fp3 += 2;
+    }
+#if 0
+    if (x->x_nprint)
+    {
+        for (i = 0,  fp = spect1; i < 16; i++,  fp+= 4)
+            post("spect %d %f %f --> %f", i, fp[0], fp[1],
+                sqrt(fp[0] * fp[0] + fp[1] * fp[1]));
+    }
+#endif
+         /* copy new spectrum out */
+    for (i = 0, fp1 = spect2, fp2 = x->x_lastanalysis;
+            i < n + 4*FILTSIZE; i++) *fp2++ = *fp1++;
+
+    for (i = 0; i < MINBIN; i++) spect1[4*i + 2] = spect1[4*i + 3] = 0;
+        /* starting at bin MINBIN, compute hanning windowed power spectrum */
+    for (i = MINBIN, fp1 = spect1+4*MINBIN, total_power = 0;
+        i < n-2; i++,  fp1 += 4)
+    {
+        float re = fp1[0] - 0.5f * (fp1[-8] + fp1[8]);
+        float im = fp1[1] - 0.5f * (fp1[-7] + fp1[9]);
+        fp1[3] = (total_power += (fp1[2] = re * re + im * im));
+    }
+
+    if (total_power > 1e-9f)
+    {
+        total_db = (100.f - DBFUDGE) + LOGTODB * log(total_power/n);
+        total_loudness = fsqrt(fsqrt(total_power));
+        if (total_db < 0) total_db = 0;
+    }
+    else total_db = total_loudness = 0;
+        /*  store new db in history vector */
+    x->x_dbs[newphase] = total_db;
+    if (total_db < x->x_amplo) goto nopow;
+#if 1
+    if (x->x_nprint) post("power %f", total_power);
+#endif
+
+#if CHECKER
+        /* verify that our FFT resampling thing is putting out good results */
+    for (i = 0; i < hop; i++)
+    {
+        checker3[2*i] = fiddle_checker[i];
+        checker3[2*i + 1] = 0;
+        checker3[n + 2*i] = fiddle_checker[i] = x->x_inbuf[i];
+        checker3[n + 2*i + 1] = 0;
+    }
+    for (i = 2*n; i < 4*n; i++) checker3[i] = 0;
+    fft(checker3, 2*n, 0);
+    if (x->x_nprint)
+    {
+        for (i = 0,  fp = checker3; i < 16; i++,  fp += 2)
+            post("spect %d %f %f --> %f", i, fp[0], fp[1],
+                sqrt(fp[0] * fp[0] + fp[1] * fp[1]));
+    }
+
+#endif
+    npeak = 0;
+
+         /* search for peaks */
+    for (i = MINBIN, fp = spect1+4*MINBIN, pk1 = peaklist;
+        i < n-2 && npeak < npeaktot; i++, fp += 4)
+    {
+        float height = fp[2], h1 = fp[-2], h2 = fp[6];
+        float totalfreq, pfreq, f1, f2, m, var, stdev;
+        
+        if (height < h1 || height < h2 ||
+            h1 < 0.00001f*total_power || h2 < 0.00001f*total_power)
+                continue;
+
+            /* use an informal phase vocoder to estimate the frequency.
+            Do this for the two adjacent bins too. */
+        pfreq= ((fp[-8] - fp[8]) * (2.0f * fp[0] - fp[8] - fp[-8]) +
+                (fp[-7] - fp[9]) * (2.0f * fp[1] - fp[9] - fp[-7])) /
+                    (2.0f * height);
+        f1=    ((fp[-12] - fp[4]) * (2.0f * fp[-4] - fp[4] - fp[-12]) +
+                (fp[-11] - fp[5]) * (2.0f * fp[-3] - fp[5] - fp[-11])) /
+                    (2.0f * h1) - 1;
+        f2=    ((fp[-4] - fp[12]) * (2.0f * fp[4] - fp[12] - fp[-4]) +
+                (fp[-3] - fp[13]) * (2.0f * fp[5] - fp[13] - fp[-3])) /
+                    (2.0f * h2) + 1;
+
+            /* get sample mean and variance of the three */
+        m = 0.333333f * (pfreq + f1 + f2);
+        var = 0.5f * ((pfreq-m)*(pfreq-m) + (f1-m)*(f1-m) + (f2-m)*(f2-m));
+
+        totalfreq = i + m;
+        if (var * total_power > KNOCKTHRESH * height || var < 1e-30)
+        {
+#if 0
+            if (x->x_nprint)
+                post("cancel: %.2f hz, index %.1f, power %.5f, stdev=%.2f",
+                    totalfreq * hzperbin, BPERO_OVER_LOG2 * log(totalfreq) - 96,
+                     height, sqrt(var));
+#endif
+            continue;
+        }
+        stdev = fsqrt(var);
+        if (totalfreq < 4)
+        {
+            if (x->x_nprint) post("oops: was %d,  freq %f, m %f, stdev %f h %f",
+                i,  totalfreq, m, stdev, height);
+            totalfreq = 4;
+        }
+        pk1->p_width = stdev;
+
+        pk1->p_pow = height;
+        pk1->p_loudness = fsqrt(fsqrt(height));
+        pk1->p_fp = fp;
+        pk1->p_freq = totalfreq;
+        npeak++;
+#if 1
+        if (x->x_nprint)
+        {
+            post("peak: %.2f hz. index %.1f, power %.5f, stdev=%.2f",
+                pk1->p_freq * hzperbin,
+                BPERO_OVER_LOG2 * log(pk1->p_freq) - 96,
+                 height, stdev);
+        }
+#endif
+        pk1++;
+    }
+
+            /* prepare the raw peaks for output */
+    for (i = 0, pk1 = peaklist, pk2 = x->x_peakbuf; i < npeak;
+        i++, pk1++, pk2++)
+    {
+        float loudness = pk1->p_loudness;
+        if (i >= npeakout) break;
+        pk2->po_freq = hzperbin * pk1->p_freq;
+        pk2->po_amp = (2.f / (float)n) * (loudness * loudness);
+    }
+    for (; i < npeakout; i++, pk2++) pk2->po_amp = pk2->po_freq = 0;
+
+        /* now, working back into spect2, make a sort of "liklihood"
+         * spectrum.  Proceeding in 48ths of an octave,  from 2 to
+         * n/2 (in bins), the likelihood of each pitch range is contributed
+         * to by every peak in peaklist that's an integer multiple of it
+         * in frequency.
+         */
+
+    if (npeak > npeakanal) npeak = npeakanal; /* max # peaks to analyze */
+    for (i = 0, fp1 = histogram; i < maxbin; i++) *fp1++ = 0;
+    for (i = 0, pk1 = peaklist; i < npeak; i++, pk1++)
+    {
+        float pit = BPERO_OVER_LOG2 * flog(pk1->p_freq) - 96.0f;
+        float binbandwidth = FACTORTOBINS * pk1->p_width/pk1->p_freq;
+        float putbandwidth = (binbandwidth < 2 ? 2 : binbandwidth);
+        float weightbandwidth = (binbandwidth < 1.0f ? 1.0f : binbandwidth);
+        /* float weightamp = 1.0f + 3.0f * pk1->p_pow / pow; */
+        float weightamp = 4. * pk1->p_loudness / total_loudness;
+        for (j = 0, fp2 = sigfiddle_partialonset; j < NPARTIALONSET; j++, fp2++)
+        {
+            float bin = pit - *fp2;
+            if (bin < maxbin)
+            {
+                float para, pphase, score = 30.0f * weightamp /
+                    ((j+x->x_npartial) * weightbandwidth);
+                int firstbin = bin + 0.5f - 0.5f * putbandwidth;
+                int lastbin = bin + 0.5f + 0.5f * putbandwidth;
+                int ibw = lastbin - firstbin;
+                if (firstbin < -BINGUARD) break;
+                para = 1.0f / (putbandwidth * putbandwidth);
+                for (k = 0, fp3 = histogram + firstbin,
+                    pphase = firstbin-bin; k <= ibw;
+                        k++, fp3++,  pphase += 1.0f)
+                {
+                    *fp3 += score * (1.0f - para * pphase * pphase);
+                }
+            }
+        }
+    }
+#if 1
+    if (x->x_nprint)
+    {
+        for (i = 0; i < 6*5; i++)
+        {
+            float fhz = hzperbin * exp ((8*i + 96) * (1./BPERO_OVER_LOG2));
+            if (!(i % 6)) post("-- bin %d pitch %f freq %f----", 8*i,
+                ftom(fhz), fhz);;
+            post("%3d %3d %3d %3d %3d %3d %3d %3d",
+                (int)(histogram[8*i]),
+                (int)(histogram[8*i+1]),
+                (int)(histogram[8*i+2]),
+                (int)(histogram[8*i+3]),
+                (int)(histogram[8*i+4]),
+                (int)(histogram[8*i+5]),
+                (int)(histogram[8*i+6]),
+                (int)(histogram[8*i+7]));
+        }
+    }
+
+#endif
+
+        /*
+         * Next we find up to NPITCH strongest peaks in the histogram.
+         * if a peak is related to a stronger one via an interval in
+         * the sigfiddle_partialonset array,  we suppress it.
+         */
+
+    for (npitch = 0; npitch < x->x_npitch; npitch++)
+    {
+        int indx;
+        float best;
+        if (npitch)
+        {
+            for (best = 0, indx = -1, j=1; j < maxbin-1; j++)
+            {
+                if (histogram[j] > best && histogram[j] > histogram[j-1] &&
+                    histogram[j] > histogram[j+1])
+                {
+                    for (k = 0; k < npitch; k++)
+                        if (histvec[k].h_index == j)
+                            goto peaknogood;
+                    for (k = 0; k < NPARTIALONSET; k++)
+                    {
+                        if (j - sigfiddle_intpartialonset[k] < 0) break;
+                        if (histogram[j - sigfiddle_intpartialonset[k]]
+                            > histogram[j]) goto peaknogood;
+                    }
+                    for (k = 0; k < NPARTIALONSET; k++)
+                    {
+                        if (j + sigfiddle_intpartialonset[k] >= maxbin) break;
+                        if (histogram[j + sigfiddle_intpartialonset[k]]
+                            > histogram[j]) goto peaknogood;
+                    }
+                    indx = j;
+                    best = histogram[j];
+                }
+            peaknogood: ;
+            }
+        }
+        else
+        {
+            for (best = 0, indx = -1, j=0; j < maxbin; j++)
+                if (histogram[j] > best)
+                    indx = j,  best = histogram[j];
+        }
+        if (indx < 0) break;
+        histvec[npitch].h_value = best;
+        histvec[npitch].h_index = indx;
+    }
+#if 1
+    if (x->x_nprint)
+    {
+        for (i = 0; i < npitch; i++)
+        {
+            post("index %d freq %f --> value %f", histvec[i].h_index,
+                exp((1./BPERO_OVER_LOG2) * (histvec[i].h_index + 96)),
+                histvec[i].h_value);
+            post("next %f , prev %f",
+                exp((1./BPERO_OVER_LOG2) * (histvec[i].h_index + 97)),
+                exp((1./BPERO_OVER_LOG2) * (histvec[i].h_index + 95)) );
+        }
+    }
+#endif
+
+        /* for each histogram peak, we now search back through the
+         * FFT peaks.  A peak is a pitch if either there are several
+         * harmonics that match it,  or else if (a) the fundamental is
+         * present,  and (b) the sum of the powers of the contributing peaks
+         * is at least 1/100 of the total power.
+         *
+         * A peak is a contributor if its frequency is within 25 cents of
+         * a partial from 1 to 16.
+         *
+         * Finally, we have to be at least 5 bins in frequency, which
+         * corresponds to 2-1/5 periods fitting in the analysis window.
+         */
+
+    for (i = 0; i < npitch; i++)
+    {
+        float cumpow = 0, cumstrength = 0, freqnum = 0, freqden = 0;
+        int npartials = 0,  nbelow8 = 0;
+            /* guessed-at frequency in bins */
+        float putfreq = fexp((1.0f / BPERO_OVER_LOG2) *
+            (histvec[i].h_index + 96.0f));
+        for (j = 0; j < npeak; j++)
+        {
+            float fpnum = peaklist[j].p_freq/putfreq;
+            int pnum = fpnum + 0.5f;
+            float fipnum = pnum;
+            float deviation;
+            if (pnum > 16 || pnum < 1) continue;
+            deviation = 1.0f - fpnum/fipnum;
+            if (deviation > -PARTIALDEVIANCE && deviation < PARTIALDEVIANCE)
+            {
+                /*
+                 * we figure this is a partial since it's within 1/4 of
+                 * a halftone of a multiple of the putative frequency.
+                 */
+
+                float stdev, weight;
+                npartials++;
+                if (pnum < 8) nbelow8++;
+                cumpow += peaklist[j].p_pow;
+                cumstrength += fsqrt(fsqrt(peaklist[j].p_pow));
+                stdev = (peaklist[j].p_width > MINBW ?
+                    peaklist[j].p_width : MINBW);
+                weight = 1.0f / ((stdev*fipnum) * (stdev*fipnum));
+                freqden += weight;
+                freqnum += weight * peaklist[j].p_freq/fipnum;          
+#if 1
+                if (x->x_nprint)
+                {
+                    post("peak %d partial %d f=%f w=%f",
+                        j, pnum, peaklist[j].p_freq/fipnum, weight);
+                }
+#endif
+            }
+#if 1
+            else if (x->x_nprint) post("peak %d partial %d dev %f",
+                        j, pnum, deviation);
+#endif
+        }
+        if ((nbelow8 < 4 || npartials < 7) && cumpow < 0.01f * total_power)
+            histvec[i].h_value = 0;
+        else
+        {
+            float pitchpow = (cumstrength * cumstrength) *
+                (cumstrength * cumstrength);
+            float freqinbins = freqnum/freqden;
+                /* check for minimum output frequency */
+
+            if (freqinbins < MINFREQINBINS)
+                histvec[i].h_value = 0;
+            else
+            {
+                    /* we passed all tests... save the values we got */
+                histvec[i].h_pitch = ftom(hzperbin * freqnum/freqden);
+                histvec[i].h_loud = (100.0f -DBFUDGE) +
+                    (LOGTODB) * log(pitchpow/n);
+            }
+        }
+    }
+#if 1
+    if (x->x_nprint)
+    {
+        for (i = 0; i < npitch; i++)
+        {
+            if (histvec[i].h_value > 0)
+                post("index %d pit %f loud %f", histvec[i].h_index,
+                histvec[i].h_pitch, histvec[i].h_loud);
+            else post("-- cancelled --");
+        }
+    }
+#endif
+
+        /* now try to find continuous pitch tracks that match the new
+         * pitches.  First mark each peak unmatched.
+         */
+    for (i = 0, hp1 = histvec; i < npitch; i++, hp1++)
+        hp1->h_used = 0;
+
+        /* for each old pitch, try to match a new one to it. */
+    for (i = 0, phist = x->x_hist; i < x->x_npitch; i++,  phist++)
+    {
+        float thispitch = phist->h_pitches[oldphase];
+        phist->h_pitch = 0;         /* no output, thanks */
+        phist->h_wherefrom = 0;
+        if (thispitch == 0.0f) continue;
+        for (j = 0, hp1 = histvec; j < npitch; j++, hp1++)
+            if ((hp1->h_value > 0) && hp1->h_pitch > thispitch - GLISS
+                && hp1->h_pitch < thispitch + GLISS)
+        {
+            phist->h_wherefrom = hp1;
+            hp1->h_used = 1;
+        }
+    }
+    for (i = 0, hp1 = histvec; i < npitch; i++, hp1++)
+        if ((hp1->h_value > 0) && !hp1->h_used)
+    {
+        for (j = 0, phist = x->x_hist; j < x->x_npitch; j++,  phist++)
+            if (!phist->h_wherefrom)
+        {
+            phist->h_wherefrom = hp1;
+            phist->h_age = 0;
+            phist->h_noted = 0;
+            hp1->h_used = 1;
+            goto happy;
+        }
+        break;
+    happy: ;
+    }
+        /* copy the pitch info into the history vector */
+    for (i = 0, phist = x->x_hist; i < x->x_npitch; i++,  phist++)
+    {
+        if (phist->h_wherefrom)
+        {
+            phist->h_amps[newphase] = phist->h_wherefrom->h_loud;
+            phist->h_pitches[newphase] =
+                phist->h_wherefrom->h_pitch;
+            (phist->h_age)++;
+        }
+        else
+        {
+            phist->h_age = 0;
+            phist->h_amps[newphase] = phist->h_pitches[newphase] = 0;
+        }
+    }
+#if 1
+    if (x->x_nprint)
+    {
+        post("vibrato %d %f", x->x_vibbins, x->x_vibdepth);
+        for (i = 0, phist = x->x_hist; i < x->x_npitch; i++,  phist++)
+        {
+            post("noted %f, age %d", phist->h_noted,  phist->h_age);
+#ifndef I860
+            post("values %f %f %f %f %f",
+                phist->h_pitches[newphase],
+                phist->h_pitches[(newphase + HISTORY-1)%HISTORY],
+                phist->h_pitches[(newphase + HISTORY-2)%HISTORY],
+                phist->h_pitches[(newphase + HISTORY-3)%HISTORY],
+                phist->h_pitches[(newphase + HISTORY-4)%HISTORY]);
+#endif
+        }
+    }
+#endif
+        /* look for envelope attacks */
+
+    x->x_attackvalue = 0;
+
+    if (x->x_peaked)
+    {
+        if (total_db > x->x_amphi)
+        {
+            int binlook = newphase - x->x_attackbins;
+            if (binlook < 0) binlook += HISTORY;
+            if (total_db > x->x_dbs[binlook] + x->x_attackthresh)
+            {
+                x->x_attackvalue = 1;
+                x->x_peaked = 0;
+            }
+        }
+    }
+    else
+    {
+        int binlook = newphase - x->x_attackbins;
+        if (binlook < 0) binlook += HISTORY;
+        if (x->x_dbs[binlook] > x->x_amphi && x->x_dbs[binlook] > total_db)
+            x->x_peaked = 1;
+    }
+
+        /* for each current frequency track, test for a new note using a
+         * stability criterion.  Later perhaps we should also do as in
+         * pitch~ and check for unstable notes a posteriori when
+         * there's a new attack with no note found since the last onset;
+         * but what's an attack &/or onset when we're polyphonic?
+         */
+
+    for (i = 0, phist = x->x_hist; i < x->x_npitch; i++,  phist++)
+    {
+            /*
+             * if we've found a pitch but we've now strayed from it turn
+             * it off.
+             */
+        if (phist->h_noted)
+        {
+            if (phist->h_pitches[newphase] > phist->h_noted + x->x_vibdepth
+                || phist->h_pitches[newphase] < phist->h_noted - x->x_vibdepth)
+                    phist->h_noted = 0;
+        }
+        else
+        {
+            if (phist->h_wherefrom && phist->h_age >= x->x_vibbins)
+            {
+                float centroid = 0;
+                int not = 0;
+                for (j = 0, k = newphase; j < x->x_vibbins; j++)
+                {
+                    centroid += phist->h_pitches[k];
+                    k--;
+                    if (k < 0) k = HISTORY-1;
+                }
+                centroid /= x->x_vibbins;
+                for (j = 0, k = newphase; j < x->x_vibbins; j++)
+                {
+                        /* calculate deviation from norm */
+                    float dev = centroid - phist->h_pitches[k];
+                    k--;
+                    if (k < 0) k = HISTORY-1;
+                    if (dev > x->x_vibdepth ||
+                        -dev > x->x_vibdepth) not = 1;
+                }
+                if (!not)
+                {
+                    phist->h_pitch = phist->h_noted = centroid;
+                }
+            }
+        }
+    }
+    return;
+
+nopow:
+    for (i = 0; i < x->x_npitch; i++)
+    {
+        x->x_hist[i].h_pitch = x->x_hist[i].h_noted =
+            x->x_hist[i].h_pitches[newphase] =
+            x->x_hist[i].h_amps[newphase] = 0;
+        x->x_hist[i].h_age = 0;
+    }
+    x->x_peaked = 1;
+    x->x_dbage = 0;
+}
+
+void sigfiddle_debug(t_sigfiddle *x)
+{
+    x->x_nprint = 1;
+}
+
+void sigfiddle_print(t_sigfiddle *x)
+{
+    post("npoints %d,",  2 * x->x_hop);
+    post("amp-range %f %f,",  x->x_amplo, x->x_amphi);
+    post("reattack %d %f,",  x->x_attacktime, x->x_attackthresh);
+    post("vibrato %d %f",  x->x_vibtime, x->x_vibdepth);
+    post("npartial %f",  x->x_npartial);
+    post("auto %d",  x->x_auto);
+}
+
+void sigfiddle_amprange(t_sigfiddle *x, t_floatarg amplo, t_floatarg amphi)
+{
+    if (amplo < 0) amplo = 0;
+    if (amphi < amplo) amphi = amplo + 1;
+    x->x_amplo = amplo;
+    x->x_amphi = amphi;
+}
+
+void sigfiddle_reattack(t_sigfiddle *x,
+    t_floatarg attacktime, t_floatarg attackthresh)
+{
+    if (attacktime < 0) attacktime = 0;
+    if (attackthresh <= 0) attackthresh = 1000;
+    x->x_attacktime = attacktime;
+    x->x_attackthresh = attackthresh;
+    x->x_attackbins = (x->x_sr * 0.001 * attacktime) / x->x_hop;
+    if (x->x_attackbins >= HISTORY) x->x_attackbins = HISTORY - 1;
+}
+
+void sigfiddle_vibrato(t_sigfiddle *x, t_floatarg vibtime, t_floatarg vibdepth)
+{
+    if (vibtime < 0) vibtime = 0;
+    if (vibdepth <= 0) vibdepth = 1000;
+    x->x_vibtime = vibtime;
+    x->x_vibdepth = vibdepth;
+    x->x_vibbins = (x->x_sr * 0.001  * vibtime) / x->x_hop;
+    if (x->x_vibbins >= HISTORY) x->x_vibbins = HISTORY - 1;
+    if (x->x_vibbins < 1) x->x_vibbins = 1;
+}
+
+void sigfiddle_npartial(t_sigfiddle *x, t_floatarg npartial)
+{
+    if (npartial < 0.1) npartial = 0.1;
+    x->x_npartial = npartial;
+}
+
+void sigfiddle_auto(t_sigfiddle *x, t_floatarg f)
+{
+    x->x_auto = (f != 0);
+}
+
+static void sigfiddle_freebird(t_sigfiddle *x)
+{
+    if (x->x_inbuf)
+    {
+        freebytes(x->x_inbuf, sizeof(float) * x->x_hop);
+        x->x_inbuf = 0;
+    }
+    if (x->x_lastanalysis)
+    {
+        freebytes(x->x_lastanalysis,
+            sizeof(float) * (2 * x->x_hop + 4 * FILTSIZE));
+        x->x_lastanalysis = 0;
+    }
+    if (x->x_spiral)
+    {
+        freebytes(x->x_spiral, sizeof(float) * 2 * x->x_hop);
+        x->x_spiral = 0;
+    }
+    x->x_hop = 0;
+}
+
+int sigfiddle_setnpoints(t_sigfiddle *x, t_floatarg fnpoints)
+{
+    int i, npoints = fnpoints;
+    sigfiddle_freebird(x);
+    if (npoints < MINPOINTS || npoints > MAXPOINTS)
+    {
+        error("fiddle~: npoints out of range; using %d",
+            npoints = DEFAULTPOINTS);
+    }
+    if (npoints != (1 << sigfiddle_ilog2(npoints)))
+    {
+        error("fiddle~: npoints not a power of 2; using %d", 
+            npoints = (1 << sigfiddle_ilog2(npoints)));
+    }
+    x->x_hop = npoints >> 1;
+    if (!(x->x_inbuf = (float *)getbytes(sizeof(float) * x->x_hop)))
+        goto fail;
+    if (!(x->x_lastanalysis = (float *)getbytes(
+        sizeof(float) * (2 * x->x_hop + 4 * FILTSIZE))))
+            goto fail;
+    if (!(x->x_spiral = (float *)getbytes(sizeof(float) * 2 * x->x_hop)))
+        goto fail;
+    for (i = 0; i < x->x_hop; i++)
+        x->x_inbuf[i] = 0;
+    for (i = 0; i < npoints + 4 * FILTSIZE; i++)
+        x->x_lastanalysis[i] = 0;
+    for (i = 0; i < x->x_hop; i++)
+        x->x_spiral[2*i] =    cos((3.14159*i)/(npoints)),
+        x->x_spiral[2*i+1] = -sin((3.14159*i)/(npoints));
+    x->x_phase = 0;
+    return (1);
+fail:
+    sigfiddle_freebird(x);
+    return (0);
+}
+
+int sigfiddle_doinit(t_sigfiddle *x, long npoints, long npitch,
+    long npeakanal, long npeakout)
+{
+    float *buf1, *buf2,  *buf3;
+    t_peakout *buf4;
+    int i;
+
+    if (!npeakanal && !npeakout) npeakanal = DEFNPEAK, npeakout = 0;
+    if (!npeakanal < 0) npeakanal = 0;
+    else if (npeakanal > MAXPEAK) npeakanal = MAXPEAK;
+    if (!npeakout < 0) npeakout = 0;
+    else if (npeakout > MAXPEAK) npeakout = MAXPEAK;
+    if (npitch <= 0) npitch = 0;
+    else if (npitch > MAXNPITCH) npitch = MAXNPITCH;
+    if (npeakanal && !npitch) npitch = 1;
+    if (!npoints)
+        npoints = DEFAULTPOINTS;
+    if (!sigfiddle_setnpoints(x, npoints))
+    {
+        error("fiddle~: out of memory");
+        return (0);
+    }
+    if (!(buf4 = (t_peakout *)getbytes(sizeof(*buf4) * npeakout)))
+    {
+        sigfiddle_freebird(x);
+        error("fiddle~: out of memory");
+        return (0);
+    }
+    for (i = 0; i < npeakout; i++)
+        buf4[i].po_freq = buf4[i].po_amp = 0;
+    x->x_peakbuf = buf4;
+
+    x->x_npeakout = npeakout;
+    x->x_npeakanal = npeakanal;
+    x->x_phase = 0;
+    x->x_histphase = 0;
+    x->x_sr = 44100;            /* this and the next are filled in later */
+    for (i = 0; i < MAXNPITCH; i++)
+    {
+        int j;
+        x->x_hist[i].h_pitch = x->x_hist[i].h_noted = 0;
+        x->x_hist[i].h_age = 0;
+        x->x_hist[i].h_wherefrom = 0;
+        x->x_hist[i].h_outlet = 0;
+        for (j = 0; j < HISTORY; j++)
+            x->x_hist[i].h_amps[j] = x->x_hist[i].h_pitches[j] = 0;
+    }
+    x->x_nprint = 0;
+    x->x_npitch = npitch;
+    for (i = 0; i < HISTORY; i++) x->x_dbs[i] = 0;
+    x->x_dbage = 0;
+    x->x_peaked = 0;
+    x->x_auto = 1;
+    x->x_amplo = DEFAMPLO;
+    x->x_amphi = DEFAMPHI;
+    x->x_attacktime = DEFATTACKTIME;
+    x->x_attackbins = 1;                /* real value calculated afterward */
+    x->x_attackthresh = DEFATTACKTHRESH;
+    x->x_vibtime = DEFVIBTIME;
+    x->x_vibbins = 1;                   /* real value calculated afterward */
+    x->x_vibdepth = DEFVIBDEPTH;
+    x->x_npartial = 7;
+    x->x_attackvalue = 0;
+    return (1);
+}
+
+    /* formalities for JMAX */
+
+#ifdef JMAX
+
+void sigfiddle_debug13(fts_object_t *o, int winlet, fts_symbol_t s, int ac, const fts_atom_t *at)
+{
+  t_sigfiddle *x = (t_sigfiddle *)o;
+  sigfiddle_debug(x);
+}
+
+void sigfiddle_print13(fts_object_t *o, int winlet, fts_symbol_t s,
+    int ac, const fts_atom_t *at)
+{
+  t_sigfiddle *x = (t_sigfiddle *)o;
+  sigfiddle_print(x);
+}
+
+void sigfiddle_amprange13(fts_object_t *o, int winlet, fts_symbol_t s,
+    int ac, const fts_atom_t *at)
+{
+    t_sigfiddle *x = (t_sigfiddle *)o;
+    float lo =  (float) fts_get_float_arg(ac, at, 0, 0);
+    float hi =  (float) fts_get_float_arg(ac, at, 1, 0);
+    sigfiddle_amprange(x, lo, hi);
+}
+
+void sigfiddle_reattack13(fts_object_t *o, int winlet, fts_symbol_t s,
+    int ac, const fts_atom_t *at)
+{
+    t_sigfiddle *x = (t_sigfiddle *)o;
+    long msec =  fts_get_float_arg(ac, at, 0, 0);
+    float db =  (float) fts_get_float_arg(ac, at, 1, 0);
+    sigfiddle_reattack(x, msec, db);
+}
+
+void sigfiddle_vibrato13(fts_object_t *o, int winlet, fts_symbol_t s,
+    int ac, const fts_atom_t *at)
+{
+    t_sigfiddle *x = (t_sigfiddle *)o;
+    long msec =  fts_get_float_arg(ac, at, 0, 0);
+    float halftones =  (float) fts_get_float_arg(ac, at, 1, 0);
+    sigfiddle_vibrato(x, msec, halftones);
+}
+
+void sigfiddle_npartial13(fts_object_t *o, int winlet, fts_symbol_t s,
+    int ac, const fts_atom_t *at)
+{
+    t_sigfiddle *x = (t_sigfiddle *)o;
+    float npartial =  (float) fts_get_float_arg(ac, at, 0, 0);
+    sigfiddle_npartial(x, npartial);
+}
+
+
+void ftl_sigfiddle(fts_word_t *a)
+{
+    t_sigfiddle *x = (t_sigfiddle *)fts_word_get_long(a);
+    float *in = (float *)fts_word_get_long(a + 1);
+    long n_tick = fts_word_get_long(a + 2);
+
+    int count;
+    float *fp,  *fp2;
+    for (count = 0, fp = x->x_inbuf + x->x_phase;
+            count < n_tick; count++) *fp++ = *in++;
+    if (fp == x->x_inbuf + x->x_hop)
+    {
+        sigfiddle_doit(x);
+        x->x_phase = 0;
+        fts_alarm_set_delay(&x->x_clock, 0L);        /* output bang */
+        fts_alarm_arm(&x->x_clock);
+
+        if (x->x_nprint) x->x_nprint--;
+    }
+    else x->x_phase += n_tick;
+}
+
+void sigfiddle_put(fts_object_t *o, int winlet, fts_symbol_t *s, int ac, const fts_atom_t *at)
+{
+    t_sigfiddle *x = (t_sigfiddle *)o;
+    fts_dsp_descr_t *dsp = (fts_dsp_descr_t *)fts_get_long_arg(ac, at, 0, 0);
+    fts_atom_t a[3];
+
+    x->x_sr = fts_dsp_get_input_srate(dsp, 0);
+    sigfiddle_reattack(x, x->x_attacktime, x->x_attackthresh);
+    sigfiddle_vibrato(x, x->x_vibtime, x->x_vibdepth);
+
+    fts_set_long(a, (long)x);
+    fts_set_symbol(a+1, fts_dsp_get_input_name(dsp, 0));
+    fts_set_long(a+2, fts_dsp_get_input_size(dsp, 0));
+    dsp_add_funcall(dsp_symbol, 3, a);
+}
+
+void sigfiddle_tick(fts_alarm_t *alarm, void *p)
+{
+    fts_object_t *o = (fts_object_t *)p;
+    t_sigfiddle *x = (t_sigfiddle *)p;
+
+    int i;
+    t_pitchhist *ph;
+    fts_outlet_float(o, OUTLETpower, x->x_dbs[x->x_histphase]);
+    for (i = 0,  ph = x->x_hist; i < x->x_npitch; i++,  ph++)
+    {
+        fts_atom_t at[2];
+        fts_set_float(at, ph->h_pitches[x->x_histphase]);
+        fts_set_float(at+1, ph->h_amps[x->x_histphase]);
+        fts_outlet_list(o, OUTLETmicropitch3 - i, 2, at);
+    }
+    if (x->x_attackvalue) fts_outlet_bang(o, OUTLETattack);
+    for (i = 0,  ph = x->x_hist; i < x->x_npitch; i++,  ph++)
+        if (ph->h_pitch) fts_outlet_float(o, OUTLETpitch, ph->h_pitch);
+}
+
+static void sigfiddle_delete(fts_object_t *o, int winlet, fts_symbol_t *s, int ac,
+ const fts_atom_t *at)
+{
+  t_sigfiddle *x = (t_sigfiddle *)o;
+
+  fts_free(x->x_inbuf);
+  fts_free(x->x_lastanalysis);
+  fts_free(x->x_spiral);
+  dsp_list_remove(o);
+}
+
+static void sigfiddle_init(fts_object_t *o, int winlet, fts_symbol_t *s, int ac, const fts_atom_t *at)
+{
+    t_sigfiddle *x = (t_sigfiddle *)o;
+    float *buf1, *buf2,  *buf3;
+    int i, hop;
+    long npoints    = fts_get_long_arg(ac, at, 1, 0);
+    long npitch    = fts_get_long_arg(ac, at, 2, 0);
+    long npeakanal    = fts_get_long_arg(ac, at, 3, 0);
+    long npeakout    = fts_get_long_arg(ac, at, 4, 0);
+
+    if (!sigfiddle_doinit(x, npoints, npitch, npeakanal, npeakout))
+    {
+        post("fiddle~: initialization failed");
+        return;
+    }
+    hop = npoints>>1;
+    if (fts_fft_declaresize(hop) != fts_Success)
+        post("fiddle~: bad FFT size");
+
+    fts_alarm_init(&(x->x_clock), 0, sigfiddle_tick, x);
+    dsp_list_insert(o);
+}
+
+static fts_status_t sigfiddle_instantiate(fts_class_t *cl, int ac,
+    const fts_atom_t *at)
+{
+  int i;
+  fts_type_t a[5];
+
+  fts_class_init(cl, sizeof(t_sigfiddle), 1, 6, 0);  /* 1 inlet + 6 outlets */
+
+  /* the system methods */
+
+  a[0] = fts_Symbol;
+  a[1] = fts_Long | fts_OptArg;
+  a[2] = fts_Long | fts_OptArg;
+  fts_method_define(cl, fts_SystemInlet, fts_s_init, sigfiddle_init, 3, a);
+
+  fts_method_define(cl, fts_SystemInlet, fts_s_delete, sigfiddle_delete, 0, a);
+  a[0] = fts_Object;
+  fts_method_define(cl, fts_SystemInlet, fts_s_put, sigfiddle_put, 1, a);
+
+  /* class' own methods */
+  fts_method_define(cl, 0, fts_new_symbol("print"), sigfiddle_print13, 0, a);
+  fts_method_define(cl, 0, fts_new_symbol("debug"), sigfiddle_debug13, 0, a);
+  fts_method_define(cl, 0, fts_new_symbol("amp-range"), sigfiddle_amprange13,
+        0, a);
+  fts_method_define(cl, 0, fts_new_symbol("reattack"), sigfiddle_reattack13,
+        0, a);
+  fts_method_define(cl, 0, fts_new_symbol("vibrato"), sigfiddle_vibrato13,
+        0, a);
+  fts_method_define(cl, 0, fts_new_symbol("npartial"), sigfiddle_npartial13,
+        0, a);
+
+  /* classes signal inlets */
+  dsp_sig_inlet(cl, 0);                    /* declare signal input #0 */
+
+  /* classes outlets */
+  a[0] = fts_Float;
+  fts_outlet_type_define(cl, OUTLETpitch, fts_s_float, 1, a); /* declare outlet #0 */
+  fts_outlet_type_define(cl, OUTLETattack, fts_s_bang, 0, a); /* declare outlet #1 */
+  a[0] = fts_VarArgs;
+  fts_outlet_type_define(cl, OUTLETmicropitch1, fts_s_list, 1, a); /* declare outlet #2 */
+  fts_outlet_type_define(cl, OUTLETmicropitch2, fts_s_list, 1, a); /* declare outlet #3 */
+  fts_outlet_type_define(cl, OUTLETmicropitch3, fts_s_list, 1, a); /* declare outlet #4 */
+  a[0] = fts_Float;
+  fts_outlet_type_define(cl, OUTLETpower, fts_s_float, 1, a); /* declare outlet #5 */
+
+  dsp_symbol = fts_new_symbol("fiddle");
+  dsp_declare_function(dsp_symbol, ftl_sigfiddle);
+
+  /* DSP properties  */
+
+  fts_class_put_prop(cl, fts_s_dsp_is_sink, fts_true);
+
+  return(fts_Success);
+}
+
+void fiddle_config(void)
+{
+  sys_log(fiddle_version);
+  fts_metaclass_create(fts_new_symbol(CLASSNAME), sigfiddle_instantiate, fts_always_equiv);
+}
+
+fts_module_t fiddle_module =
+  {"fiddle", "sonic meat fiddle", fiddle_config, 0};
+
+#endif  /* JMAX */
+
+#ifdef PD
+
+static t_int *fiddle_perform(t_int *w)
+{
+    t_float *in = (t_float *)(w[1]);
+    t_sigfiddle *x = (t_sigfiddle *)(w[2]);
+    int n = (int)(w[3]);
+    int count;
+    float *fp;
+    if (!x->x_hop)
+        goto nono;
+    for (count = 0, fp = x->x_inbuf + x->x_phase; count < n; count++)
+        *fp++ = *in++;
+    if (fp == x->x_inbuf + x->x_hop)
+    {
+        sigfiddle_doit(x);
+        x->x_phase = 0;
+        if (x->x_auto) clock_delay(x->x_clock, 0L);
+        if (x->x_nprint) x->x_nprint--;
+    }
+    else x->x_phase += n;
+nono:
+    return (w+4);
+}
+
+void sigfiddle_dsp(t_sigfiddle *x, t_signal **sp)
+{
+    x->x_sr = sp[0]->s_sr;
+    sigfiddle_reattack(x, x->x_attacktime, x->x_attackthresh);
+    sigfiddle_vibrato(x, x->x_vibtime, x->x_vibdepth);
+    dsp_add(fiddle_perform, 3, sp[0]->s_vec, x, sp[0]->s_n);
+}
+
+    /* This is the callback function for the clock, but also acts as
+    the "bang" method; you can leave "auto" on to get this called
+    automatically (the default) or turn auto off and bang it yourself. */
+
+void sigfiddle_bang(t_sigfiddle *x)
+{
+    int i;
+    t_pitchhist *ph;
+    if (x->x_npeakout)
+    {
+        int npeakout = x->x_npeakout;
+        t_peakout *po;
+        for (i = 0, po = x->x_peakbuf; i < npeakout; i++, po++)
+        {
+            t_atom at[3];
+            SETFLOAT(at, i+1);
+            SETFLOAT(at+1, po->po_freq);
+            SETFLOAT(at+2, po->po_amp);
+            outlet_list(x->x_peakout, 0, 3, at);
+        }
+    }
+    outlet_float(x->x_envout, x->x_dbs[x->x_histphase]);
+    for (i = 0,  ph = x->x_hist; i < x->x_npitch; i++,  ph++)
+    {
+        t_atom at[2];
+        SETFLOAT(at, ph->h_pitches[x->x_histphase]);
+        SETFLOAT(at+1, ph->h_amps[x->x_histphase]);
+        outlet_list(ph->h_outlet, 0, 2, at);
+    }
+    if (x->x_attackvalue) outlet_bang(x->x_attackout);
+    for (i = 0,  ph = x->x_hist; i < x->x_npitch; i++,  ph++)
+        if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch);
+}
+
+void sigfiddle_ff(t_sigfiddle *x)               /* cleanup on free */
+{
+    if (x->x_inbuf)
+    {
+        freebytes(x->x_inbuf, sizeof(float) * x->x_hop);
+        freebytes(x->x_lastanalysis, sizeof(float) * (2*x->x_hop + 4 * FILTSIZE));
+        freebytes(x->x_spiral, sizeof(float) * 2*x->x_hop);
+        freebytes(x->x_peakbuf, sizeof(*x->x_peakbuf) * x->x_npeakout);
+        clock_free(x->x_clock);
+    }
+}
+
+static t_class *sigfiddle_class;
+
+void *sigfiddle_new(t_floatarg npoints, t_floatarg npitch,
+    t_floatarg fnpeakanal, t_floatarg fnpeakout)
+{
+    t_sigfiddle *x = (t_sigfiddle *)pd_new(sigfiddle_class);
+    int i;
+    int npeakanal = fnpeakanal, npeakout = fnpeakout;
+
+
+    if (!sigfiddle_doinit(x, npoints, npitch,
+        npeakanal, npeakout))
+    {
+        x->x_inbuf = 0;     /* prevent the free routine from cleaning up */
+        pd_free(&x->x_ob.ob_pd);
+        return (0);
+    }
+    x->x_noteout = outlet_new(&x->x_ob, gensym("float"));
+    x->x_attackout = outlet_new(&x->x_ob, gensym("bang"));
+    for (i = 0; i < x->x_npitch; i++)
+        x->x_hist[i].h_outlet = outlet_new(&x->x_ob, gensym("list"));
+    x->x_envout = outlet_new(&x->x_ob, gensym("float"));
+    if (x->x_npeakout)
+        x->x_peakout = outlet_new(&x->x_ob, gensym("list"));
+    else x->x_peakout = 0;
+    x->x_clock = clock_new(&x->x_ob.ob_pd, (t_method)sigfiddle_bang);
+    return (x);
+}
+
+void fiddle_tilde_setup(void)
+{
+    sigfiddle_class = class_new(gensym("fiddle~"), (t_newmethod)sigfiddle_new,
+        (t_method)sigfiddle_ff, sizeof(t_sigfiddle), 0,
+            A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
+    class_addmethod(sigfiddle_class, (t_method)sigfiddle_dsp,
+        gensym("dsp"), 0);
+    class_addmethod(sigfiddle_class, (t_method)sigfiddle_debug,
+        gensym("debug"), 0);
+    class_addmethod(sigfiddle_class, (t_method)sigfiddle_setnpoints,
+        gensym("npoints"), A_FLOAT, 0);
+    class_addmethod(sigfiddle_class, (t_method)sigfiddle_amprange,
+        gensym("amp-range"), A_FLOAT, A_FLOAT, 0);
+    class_addmethod(sigfiddle_class, (t_method)sigfiddle_reattack,
+        gensym("reattack"), A_FLOAT, A_FLOAT, 0);
+    class_addmethod(sigfiddle_class, (t_method)sigfiddle_vibrato,
+        gensym("vibrato"), A_FLOAT, A_FLOAT, 0);
+    class_addmethod(sigfiddle_class, (t_method)sigfiddle_npartial,
+        gensym("npartial"), A_FLOAT, 0);
+    class_addmethod(sigfiddle_class, (t_method)sigfiddle_auto,
+        gensym("auto"), A_FLOAT, 0);
+    class_addmethod(sigfiddle_class, (t_method)sigfiddle_print,
+        gensym("print"), 0);
+    class_addmethod(sigfiddle_class, nullfn, gensym("signal"), 0);
+    class_addbang(sigfiddle_class, sigfiddle_bang);
+    class_addcreator((t_newmethod)sigfiddle_new, gensym("fiddle"),
+        A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
+    post(fiddle_version);
+}
+
+void fiddle_setup(void)
+{
+    fiddle_tilde_setup();
+}
+#endif /* PD */
+
+#ifdef MAX26
+
+void cu_fiddle(float *in1, t_sigfiddle *x, int n)
+{
+    int count;
+    float *fp,  *fp2;
+    for (count = 0, fp = x->x_inbuf + x->x_phase;
+            count < n; count++) *fp++ = *in1++;
+    if (fp == x->x_inbuf + x->x_hop)
+    {
+        sigfiddle_doit(x);
+        x->x_phase = 0;
+        if (x->x_auto) clock_delay(x->x_clock, 0L);
+        if (x->x_nprint) x->x_nprint--;
+    }
+    else x->x_phase += n;
+}
+
+void sigfiddle_put(t_sigfiddle *x, long whether)
+{
+    if (whether)
+    {
+        u_stdout(x);
+        x->x_sr = x->x_io[0]->s_sr;
+        sigfiddle_reattack(x, x->x_attacktime, x->x_attackthresh);
+        sigfiddle_vibrato(x, x->x_vibtime, x->x_vibdepth);
+        dspchain_addc(cu_fiddle, 3,
+            x->x_io[0]->s_shit, x, x->x_io[0]->s_n);
+    }
+}
+
+void sigfiddle_tick(t_sigfiddle *x)     /* callback function for the clock */
+{
+    int i;
+    t_pitchhist *ph;
+    outlet_float(x->x_envout, x->x_dbs[x->x_histphase]);
+    for (i = 0,  ph = x->x_hist; i < x->x_npitch; i++,  ph++)
+    {
+        t_atom at[2];
+        SETFLOAT(at, ph->h_pitches[x->x_histphase]);
+        SETFLOAT(at+1, ph->h_amps[x->x_histphase]);
+        outlet_list(ph->h_outlet, NIL, 2, at);
+    }
+    if (x->x_attackvalue) outlet_bang(x->x_attackout);
+    for (i = 0,  ph = x->x_hist; i < x->x_npitch; i++,  ph++)
+        if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch);
+}
+
+void sigfiddle_ff(t_sigfiddle *x)               /* cleanup on free */
+{
+    if (x->x_inbuf)
+    {
+        freebytes(x->x_inbuf, sizeof(float) * x->x_hop);
+        freebytes(x->x_lastanalysis, sizeof(float) * (2*x->x_hop + 4 * FILTSIZE));
+        freebytes(x->x_spiral, sizeof(float) * 2*x->x_hop);
+        clock_free(x->x_clock);
+        u_clean(x);
+    }
+}
+
+t_externclass *sigfiddle_class;
+
+void *sigfiddle_new(long npoints, long npitch,
+    long npeakanal, long npeakout)
+{
+    t_sigfiddle *x = (t_sigfiddle *)obj_new(&sigfiddle_class, 0);
+    int i;
+
+    if (!sigfiddle_doinit(x, npoints, npitch, npeakanal, npeakout))
+    {
+        x->x_inbuf = 0;     /* prevent the free routine from cleaning up */
+        obj_free(x);
+        return (0);
+    }
+    u_setup(x, IN1, OUT0);
+    x->x_envout = outlet_new(x, gensym("float"));
+    for (i = 0; i < x->x_npitch; i++)
+        x->x_hist[i].h_outlet = outlet_new(x, gensym("list"));
+    x->x_attackout = outlet_new(x, gensym("bang"));
+    x->x_noteout = outlet_new(x, gensym("float"));
+    x->x_clock = clock_new(x, sigfiddle_tick);
+    return (x);
+}
+
+void fiddle_setup()
+{
+    c_extern(&sigfiddle_class, sigfiddle_new, sigfiddle_ff,
+        gensym("fiddle"), sizeof(t_sigfiddle), 0, A_DEFLONG, A_DEFLONG,
+            A_DEFLONG, A_DEFLONG, 0);
+    c_addmess(sigfiddle_put, gensym("put"), A_CANT, 0);
+    c_addmess(sigfiddle_debug, gensym("debug"), 0);
+    c_addmess(sigfiddle_amprange, gensym("amp-range"), A_FLOAT, A_FLOAT, 0);
+    c_addmess(sigfiddle_reattack, gensym("reattack"), A_FLOAT, A_FLOAT, 0);
+    c_addmess(sigfiddle_vibrato, gensym("vibrato"), A_LONG, A_FLOAT, 0);
+    c_addmess(sigfiddle_npartial, gensym("npartial"), A_FLOAT, 0);
+    c_addmess(sigfiddle_print, gensym("print"), 0);
+    u_inletmethod(0);   /* one signal input */
+#ifdef MAX
+    post(fiddle_version);
+#endif
+}
+
+#endif /* MAX26 */
+
+/************* Beginning of MSP Code ******************************/
+
+#ifdef MSP
+
+static t_int *fiddle_perform(t_int *w)
+{
+    t_float *in = (t_float *)(w[1]);
+    t_sigfiddle *x = (t_sigfiddle *)(w[2]);
+    int n = (int)(w[3]);
+    int count,inc = x->x_downsample;
+    float *fp;
+
+    if (x->x_obj.z_disabled)
+        goto skip;
+    for (count = 0, fp = x->x_inbuf + x->x_phase; count < n; count+=inc) {
+        *fp++ = *in;
+        in += inc;
+    }
+    if (fp == x->x_inbuf + x->x_hop)
+    {
+                sigfiddle_doit(x);
+                x->x_phase = 0;
+                if (x->x_auto) clock_delay(x->x_clock, 0L);
+                if (x->x_nprint) x->x_nprint--;
+    }
+    else x->x_phase += n;
+skip:
+    return (w+4);
+}
+
+void sigfiddle_dsp(t_sigfiddle *x, t_signal **sp)
+{
+     if (sp[0]->s_n > x->x_hop) {
+        x->x_downsample = sp[0]->s_n / x->x_hop;
+        post("* warning: fiddle~: will downsample input by %ld",x->x_downsample);
+        x->x_sr = sp[0]->s_sr / x->x_downsample;
+    } else {
+        x->x_downsample = 1;
+                x->x_sr = sp[0]->s_sr;
+        }
+        sigfiddle_reattack(x, x->x_attacktime, x->x_attackthresh);
+    sigfiddle_vibrato(x, x->x_vibtime, x->x_vibdepth);
+    dsp_add(fiddle_perform, 3, sp[0]->s_vec, x, sp[0]->s_n);
+}
+
+void sigfiddle_tick(t_sigfiddle *x)     /* callback function for the clock MSP*/
+{
+    int i;
+    t_pitchhist *ph;
+    if (x->x_npeakout)
+    {
+        int npeakout = x->x_npeakout;
+        t_peakout *po;
+        for (i = 0, po = x->x_peakbuf; i < npeakout; i++, po++)
+        {
+                t_atom at[3];
+                SETINT(at, i+1);
+                SETFLOAT(at+1, po->po_freq);
+                SETFLOAT(at+2, po->po_amp);
+                outlet_list(x->x_peakout, 0, 3, at);
+                }
+    }
+    outlet_float(x->x_envout, x->x_dbs[x->x_histphase]);
+    for (i = 0,  ph = x->x_hist; i < x->x_npitch; i++,  ph++)
+    {
+        t_atom at[2];
+        SETFLOAT(at, ph->h_pitches[x->x_histphase]);
+        SETFLOAT(at+1, ph->h_amps[x->x_histphase]);
+        outlet_list(ph->h_outlet, 0, 2, at);
+    }
+    if (x->x_attackvalue) outlet_bang(x->x_attackout);
+    for (i = 0,  ph = x->x_hist; i < x->x_npitch; i++,  ph++)
+        if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch);
+}
+
+void sigfiddle_bang(t_sigfiddle *x)             
+{
+    int i;
+    t_pitchhist *ph;
+    if (x->x_npeakout)
+    {
+        int npeakout = x->x_npeakout;
+        t_peakout *po;
+        for (i = 0, po = x->x_peakbuf; i < npeakout; i++, po++)
+        {
+            t_atom at[3];
+            SETLONG(at, i+1);
+            SETFLOAT(at+1, po->po_freq);
+            SETFLOAT(at+2, po->po_amp);
+            outlet_list(x->x_peakout, 0, 3, at);
+        }
+    }
+    outlet_float(x->x_envout, x->x_dbs[x->x_histphase]);
+    for (i = 0,  ph = x->x_hist; i < x->x_npitch; i++,  ph++)
+    {
+        t_atom at[2];
+        SETFLOAT(at, ph->h_pitches[x->x_histphase]);
+        SETFLOAT(at+1, ph->h_amps[x->x_histphase]);
+        outlet_list(ph->h_outlet, 0, 2, at);
+    }
+    if (x->x_attackvalue) outlet_bang(x->x_attackout);
+    for (i = 0,  ph = x->x_hist; i < x->x_npitch; i++,  ph++)
+        if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch);
+}
+
+
+void sigfiddle_ff(t_sigfiddle *x)               /* cleanup on free  MSP  */
+{
+
+    if (x->x_inbuf)
+    {
+        t_freebytes(x->x_inbuf, sizeof(float) * x->x_hop);
+        t_freebytes(x->x_lastanalysis, sizeof(float) * (2*x->x_hop + 4 *
+FILTSIZE));
+        t_freebytes(x->x_spiral, sizeof(float) * 2*x->x_hop);
+        t_freebytes(x->x_peakbuf, sizeof(*x->x_peakbuf) * x->x_npeakout);
+    }
+     dsp_free((t_pxobject *)x);
+}
+
+void *sigfiddle_class;
+
+void *sigfiddle_new(long npoints, long npitch,
+    long npeakanal, long npeakout)
+{
+    t_sigfiddle *x = (t_sigfiddle *)newobject(sigfiddle_class);
+    int i;
+
+    if (!sigfiddle_doinit(x, npoints, npitch, npeakanal, npeakout))
+    {
+        x->x_inbuf = 0;     /* prevent the free routine from cleaning up */
+        return (0);
+    }
+    dsp_setup((t_pxobject *)x,1);
+
+    x->x_clock = clock_new(x, (method)sigfiddle_tick);
+     if (x->x_npeakout)
+        x->x_peakout = listout((t_object *)x);
+    else x->x_peakout = 0;
+    x->x_envout = floatout((t_object *)x);
+    for (i = 0; i < x->x_npitch; i++)
+                x->x_hist[i].h_outlet = listout((t_object *)x);
+        x->x_attackout = bangout((t_object *)x);
+        x->x_noteout = floatout((t_object *)x);
+          return (x);
+
+
+}
+
+void main()
+{
+        setup(&sigfiddle_class, sigfiddle_new, (method)sigfiddle_ff,
+                (short)sizeof(t_sigfiddle), 0L, A_DEFLONG, A_DEFLONG,
+A_DEFLONG, A_DEFLONG, 0);
+        addmess((method)sigfiddle_dsp,          "dsp",
+        A_CANT, 0);
+    addmess((method)sigfiddle_debug,    "debug",                0);
+    addmess((method)sigfiddle_setnpoints, "npoints",    A_FLOAT, 0);
+    addmess((method)sigfiddle_amprange, "amp-range",    A_FLOAT, A_FLOAT, 0);
+    addmess((method)sigfiddle_reattack, "reattack",     A_FLOAT, A_FLOAT, 0);
+    addmess((method)sigfiddle_vibrato,  "vibrato",              A_FLOAT,
+A_FLOAT, 0);
+    addmess((method)sigfiddle_npartial, "npartial",     A_FLOAT, 0);
+    addmess((method)sigfiddle_auto,             "auto",
+        A_FLOAT, 0);
+    addmess((method)sigfiddle_print,    "print",                0);
+        addmess((method)sigfiddle_assist,       "assist",
+        A_CANT, 0);
+        addbang((method)sigfiddle_bang);
+    dsp_initclass();
+    rescopy('STR#',3748);
+    post(fiddle_version);
+}
+
+void sigfiddle_assist(t_sigfiddle *x, void *b, long m, long a, char *s)
+{
+        assist_string(3748,m,a,1,2,s);
+}
+
+void msp_fft(float *buf, long np, long inv)
+{
+        float *src,*real,*rp,*imag,*ip;
+        long i;
+
+        /*
+        // because this fft algorithm uses separate real and imaginary
+        // buffers
+        // we must split the real and imaginary parts into two buffers,
+        // then do the opposite on output
+        // a more ambitious person would either do an in-place conversion
+        // or rewrite the fft algorithm
+        */
+    
+        real = rp = msp_ffttemp;
+        imag = ip = real + MAXPOINTS;
+        src = buf;
+        for (i = 0; i < np; i++) {
+                *rp++ = *src++;
+                *ip++ = *src++;
+        }
+        if (inv)
+                ifft(np,real,imag);
+        else
+                fft(np,real,imag);
+        rp = real;
+        ip = imag;
+        src = buf;
+        for (i = 0; i < np; i++) {
+                *src++ = *rp++;
+                *src++ = *ip++;
+        }
+}
+
+#endif /* MSP */
diff --git a/desiredata/extra/fiddle~/makefile b/desiredata/extra/fiddle~/makefile
new file mode 100644
index 00000000..247c905e
--- /dev/null
+++ b/desiredata/extra/fiddle~/makefile
@@ -0,0 +1,4 @@
+NAME=fiddle~
+CSYM=fiddle_tilde
+
+include ../makefile
diff --git a/desiredata/extra/help-complex-mod~.pd b/desiredata/extra/help-complex-mod~.pd
new file mode 100644
index 00000000..9e14904d
--- /dev/null
+++ b/desiredata/extra/help-complex-mod~.pd
@@ -0,0 +1,26 @@
+#N canvas 136 85 600 480 12;
+#X graph graph1 0 -1 882 1 279 209 579 39;
+#X array mod-output 882 float;
+#X pop;
+#X msg 84 256 bang \; pd dsp 1;
+#X floatatom 67 56;
+#X obj 67 186 complex-mod~;
+#X obj 67 84 phasor~ 440;
+#X obj 67 115 cos~;
+#X obj 106 138 cos~;
+#X obj 106 114 -~ 0.25;
+#X floatatom 145 152;
+#X text 93 351 The complex modulator takes two signals in which it considers to be the real and imaginary part of a complex-valued signal. It then does a complex multiplication by a sinusoud to shift all frequencies up or down by any frequency shift in Hz. See also hilbert~.;
+#X obj 69 298 tabwrite~ mod-output;
+#X text 149 204 right outlet;
+#X text 151 220 gives the other;
+#X text 149 236 sideband;
+#X connect 1 0 10 0;
+#X connect 2 0 4 0;
+#X connect 3 0 10 0;
+#X connect 4 0 5 0;
+#X connect 4 0 7 0;
+#X connect 5 0 3 0;
+#X connect 6 0 3 1;
+#X connect 7 0 6 0;
+#X connect 8 0 3 2;
diff --git a/desiredata/extra/help-expr.pd b/desiredata/extra/help-expr.pd
new file mode 100644
index 00000000..adc575fb
--- /dev/null
+++ b/desiredata/extra/help-expr.pd
@@ -0,0 +1,497 @@
+#N canvas 70 36 1012 579 10;
+#X text 66 10 expression evaluation family - expr \, expr~ \, fexpr~
+;
+#X text 63 239 Syntyax:;
+#X text 64 311 $f#: float input variable;
+#X text 65 326 $s#: symbol input variable;
+#X text 553 90 Used for expr~ only:;
+#X text 553 105 $v#: signal (vector) input (vector by vector evaluation)
+;
+#X text 550 164 Used for fexpr~ only:;
+#X text 550 220 $y[n]: the output value indexed by n where n has to
+satisfy 0 > n >= -vector size.;
+#X text 550 248 (the vector size can be changed by the "block~" object.)
+;
+#X text 550 179 $x#[n]: the sample from inlet # indexed by n where
+n has to satisfy 0 => n >= -vector size \, ($x# is a shorthand for
+$x#[0] \, specifying the current sample);
+#X text 63 151 expr~ is used for expression evaluaion of signal data
+on the vector by vector basis;
+#X text 63 136 expr is used for expression evaluaion of control data
+;
+#X text 67 39 For a more detailed documentaion refer to http://www.crca.ucsd.edu/~yadegari/expr.html
+;
+#X text 64 254 The syntax is very close to how expressions are written
+in C. Variables are specified as follows where the '#' stands for the
+inlet number:;
+#X text 65 297 $i#: integer input variable;
+#X text 63 179 fexpr~ is used for expression evaluaion on sample level
+data \; i.e. \, filter design. Warning: fexpr~ is very cpu intensive.
+;
+#X text 633 12 updated for Pd 0.35 test 26 and expr* 0.4;
+#X text 67 85 you can define multiple expressoins in the same object.
+semicolon is used to separates the expressions.;
+#X text 635 294 $y -> $y1[-1];
+#X text 550 263 Shorthands: $x -> $x1[0];
+#X text 635 279 $x1 -> $x1[0] $x2 -> $x2[0] .....;
+#X text 635 309 $y1 -> $y1[-1] $y2 -> $y2[-1] .....;
+#N canvas 0 0 828 385 Examples 0;
+#X obj 33 151 expr 1;
+#X floatatom 197 119 0 0 0;
+#X floatatom 33 181 0 0 0;
+#X msg 33 123 bang;
+#X obj 101 149 expr 2 + 3;
+#X msg 101 122 bang;
+#X floatatom 101 177 0 0 0;
+#X floatatom 196 177 0 0 0;
+#X obj 196 149 expr 2+$f1;
+#X floatatom 34 220 0 0 0;
+#X floatatom 34 277 0 0 0;
+#X obj 34 249 expr $f1 * $f2;
+#X floatatom 113 220 0 0 0;
+#N canvas 0 0 450 300 graph1 0;
+#X array array1 10 float 0;
+#X coords 0 10 10 0 200 150 1;
+#X restore 584 180 graph;
+#X floatatom 35 315 0 0 0;
+#X floatatom 35 371 0 0 0;
+#X floatatom 194 219 0 0 0;
+#X floatatom 194 276 0 0 0;
+#X obj 194 248 expr $s2[$f1];
+#X msg 267 220 symbol array1;
+#X obj 35 343 expr sin(2 * 3.14159 * $f1 / 360);
+#X msg 330 281 \; array1 1 4 2 8 5 6 1 4 2 8 5 6;
+#X floatatom 310 184 5 0 0;
+#X floatatom 395 186 5 0 0;
+#X floatatom 480 184 5 0 0;
+#X floatatom 310 105 5 0 0;
+#X obj 310 132 expr $f1 \; if ($f1 > 0 \, $f1 * 2 \, 0) \; if ($f1
+<= 0 \, $f1 / 2 \, 0);
+#X text 34 56 Examples of expr object;
+#X text 304 88 an example of multiple expressions and the use of 'if'
+;
+#X connect 0 0 2 0;
+#X connect 1 0 8 0;
+#X connect 3 0 0 0;
+#X connect 4 0 6 0;
+#X connect 5 0 4 0;
+#X connect 8 0 7 0;
+#X connect 9 0 11 0;
+#X connect 11 0 10 0;
+#X connect 12 0 11 1;
+#X connect 14 0 20 0;
+#X connect 16 0 18 0;
+#X connect 18 0 17 0;
+#X connect 19 0 18 1;
+#X connect 20 0 15 0;
+#X connect 25 0 26 0;
+#X connect 26 0 22 0;
+#X connect 26 1 23 0;
+#X connect 26 2 24 0;
+#X restore 307 398 pd Examples of expr;
+#N canvas 23 24 882 676 Examples 0;
+#X text -88 101 expr~ examples:;
+#X obj -24 355 print~;
+#X msg 13 334 bang;
+#X obj -24 276 sig~ 440;
+#X floatatom 49 293 0 0 0;
+#X floatatom -24 253 0 0 0;
+#X obj -24 316 expr~ $v1*$f2;
+#X obj 85 356 print~;
+#X msg 101 335 bang;
+#X floatatom 85 268 0 0 0;
+#X floatatom 158 270 0 0 0;
+#X floatatom 357 291 0 0 0;
+#X floatatom 244 267 0 0 0;
+#X obj 244 294 osc~;
+#X msg 369 47 \; pd dsp 0;
+#X msg 291 49 \; pd dsp 1;
+#X text 294 26 audio on;
+#X text 377 25 audio off;
+#X text -45 236 vector times scalar;
+#X text 87 236 vector;
+#X obj 243 354 dac~;
+#X text 241 245 frequency;
+#X text 373 273 amplitude;
+#X obj 85 315 expr~ $v1*$v2;
+#X floatatom 207 471 5 0 0;
+#X obj -40 520 tabsend~ a1;
+#N canvas 0 0 450 300 graph4 0;
+#X array a1 64 float 0;
+#X coords 0 1 63 -1 200 140 1;
+#X restore -39 542 graph;
+#X obj -40 497 expr~ max(min($v1 \, $f2/10) \, -$f2/10);
+#X text -38 123 NOTES: the first inlet of expr~ cannot be a $f1 or
+$i1 \, this may change in later releases;
+#X text -87 420 A simple limiter example;
+#X obj 356 158 vsl 15 128 0 127 0 0 empty empty empty 20 8 0 8 -262144
+-1 -1 0 1;
+#X obj 243 315 expr~ $v1*$f2/128;
+#X text -82 28 make sure you turn on audio for the expr~ examples;
+#X obj -40 473 osc~ 2756.25;
+#X text 122 436 Move the value below between 0 and 10;
+#X text 126 451 to change the limiter threshold;
+#X obj 417 522 tabsend~ a2;
+#X obj 580 518 tabsend~ a3;
+#X obj 417 439 osc~ 2756.25;
+#N canvas 0 0 450 300 graph1 0;
+#X array a2 64 float 1;
+#A 0 -0.419198 -0.487122 -0.481805 -0.400382 -0.252053 -0.0571681 0.155563
+0.353314 0.504227 0.582557 0.573016 0.473664 0.296682 0.0669659 -0.18137
+-0.410083 -0.582709 -0.670415 -0.656787 -0.540803 -0.337462 -0.0758923
+0.204826 0.461522 0.653623 0.74958 0.732042 0.600932 0.373867 0.0838359
+-0.225617 -0.506972 -0.716061 -0.819026 -0.797803 -0.653251 -0.405409
+-0.0906877 0.243486 0.545852 0.769218 0.877835 0.853191 0.697093 0.431698
+0.096368 -0.258195 -0.577642 -0.812367 -0.925245 -0.897515 -0.731894
+-0.452386 -0.100793 0.269551 0.601932 0.844984 0.960659 0.930205 0.757204
+0.467199 0.103913 -0.277405 -0.618414;
+#X coords 0 1 63 -1 200 140 1;
+#X restore 347 554 graph;
+#N canvas 0 0 450 300 graph2 0;
+#X array a3 64 float 0;
+#X coords 0 1 63 -1 200 140 1;
+#X restore 569 554 graph;
+#X obj 417 473 expr~ $v1 *$v2 \; if ($v2 > 0 \, 0 \, $v1*$v2);
+#X obj 580 439 osc~ 100;
+#X connect 2 0 1 0;
+#X connect 3 0 6 0;
+#X connect 4 0 6 1;
+#X connect 5 0 3 0;
+#X connect 6 0 1 0;
+#X connect 8 0 7 0;
+#X connect 9 0 23 0;
+#X connect 10 0 23 1;
+#X connect 11 0 31 1;
+#X connect 12 0 13 0;
+#X connect 13 0 31 0;
+#X connect 23 0 7 0;
+#X connect 24 0 27 1;
+#X connect 27 0 25 0;
+#X connect 30 0 11 0;
+#X connect 31 0 20 0;
+#X connect 31 0 20 1;
+#X connect 33 0 27 0;
+#X connect 38 0 41 0;
+#X connect 41 0 36 0;
+#X connect 41 1 37 0;
+#X connect 42 0 41 1;
+#X restore 307 433 pd Examples of expr~;
+#X text 40 399 For expr examples click here ->;
+#X text 41 433 For expr~ examples click here ->;
+#X text 40 471 For fexpr~ examples click here ->;
+#N canvas 0 0 1059 688 examples 0;
+#X msg 519 84 \; pd dsp 0;
+#X msg 428 84 \; pd dsp 1;
+#X text 426 64 audio on;
+#X text 518 65 audio off;
+#X floatatom 126 304 0 0 0;
+#X floatatom 259 323 0 0 0;
+#X msg 226 283 -10;
+#X text 53 103 fexpr~ examples:;
+#X obj 125 571 print~;
+#X msg 247 552 bang;
+#X floatatom 125 475 0 0 0;
+#X obj 126 347 fexpr~ ($x1[$f2]+$x1)/2;
+#X obj 125 532 fexpr~ $x1+$y[-1];
+#X floatatom 635 366 0 0 0;
+#X floatatom 795 387 0 0 0;
+#X obj 630 456 dac~;
+#X obj 632 407 fexpr~ ($x1[$f2/1000]+$x1)/2;
+#X msg 864 317 0 10000;
+#X obj 795 368 line 0;
+#X msg 798 318 -10000;
+#X obj 120 389 dac~;
+#X text 96 227 Simple FIR filter;
+#X text 557 134 Simple FIR filter using fractional offset;
+#X msg 704 318 -10000 10000;
+#X obj 635 387 osc~ 2205;
+#X msg 644 343 1102.5;
+#X msg 862 342 0 10000;
+#X msg 796 343 -20000;
+#X msg 702 343 -20000 10000;
+#X msg 635 318 2205;
+#X msg 548 312 start;
+#X msg 550 334 stop;
+#X msg 57 284 start;
+#X msg 56 309 stop;
+#X msg 75 469 start;
+#X msg 74 494 stop;
+#X obj 491 335 loadbang;
+#X obj 18 495 loadbang;
+#X obj 1 309 loadbang;
+#X text 617 291 frequency;
+#X text 707 300 of the simple filter;
+#X msg 293 282 -20;
+#X obj 126 325 osc~ 2205;
+#X msg 156 281 1102.5;
+#X msg 110 281 2205;
+#X msg 260 282 0;
+#X text 123 445 simple accumulator defined as and an IIR filter;
+#X text 52 148 NOTE: fexpr~ could use lots of CPU power \, by default
+fexpr~ is on when it is loaded. In this page we are turning them off
+with loadbang \, so to hear them you have to turn them on explicitly.
+You can use the "start" and "stop" messages to start and stop fexpr~
+and expr~;
+#X text 706 288 index defining the frequency;
+#X text 95 240 -10 offset will fully filter audio frequency of 2205
+\, and -20 offset will filter audio at frequency of 1102.5;
+#X text 559 215 Thus \, the offset -10000 will filter audio at frequency
+of 2205 and the offset value -20000 will filter the audio at frequency
+of 1102.5.;
+#X text 558 161 When fractional offset is used \, fexpr~ determines
+indexed by linear interpolation. In the following example the offset
+value is divided by 1000 \, thus we can continuously change the offset
+without an audible click in the output.;
+#X text 288 318 If you change this value you;
+#X text 290 330 hear a click;
+#X text 51 87 make sure you turn on audio for the fexpr~ examples;
+#X text 55 -323 Used for fexpr~ only:;
+#X text 55 -267 $y[n]: the output value indexed by n where n has to
+satisfy 0 > n >= -vector size.;
+#X text 55 -239 (the vector size can be changed by the "block~" object.)
+;
+#X text 55 -308 $x#[n]: the sample from inlet # indexed by n where
+n has to satisfy 0 => n >= -vector size \, ($x# is a shorthand for
+$x#[0] \, specifying the current sample);
+#X text 140 -193 $y -> $y1[-1];
+#X text 55 -224 Shorthands: $x -> $x1[0];
+#X text 140 -208 $x1 -> $x1[0] $x2 -> $x2[0] .....;
+#X text 140 -178 $y1 -> $y1[-1] $y2 -> $y2[-1] .....;
+#X text 64 -125 fexpr~ responds to the following methods;
+#X text 66 -106 clear - clears all the previous input and output buffers
+;
+#X text 65 -92 clear x# - clears the previous values of the #th input
+;
+#X text 66 -79 clear y# - clears the previous values of the #th output
+;
+#X text 66 -33 set x# val-1 val-2 ... - sets the as many supplied values
+of the #th input;
+#X text 513 -22 e.g. \, set x2 3.4 0.4 sets x2[-1]=3.4 and x2[-2]=0.4
+;
+#X text 66 -2 set y# val-1 val-2 ... - sets the as many supplied values
+of the #th input;
+#X text 514 4 e.g. \, set y3 1.1 3.3 4.5 sets y3[-1]=1.1 y3[-2]=3.3
+and y3[-3]=4.5;
+#X text 64 -54 set val val ... - sets the first past values of each
+output;
+#X text 513 -59 e.g. \, set 0.1 2.2 0.4 sets y1[-1]=0.1 y2[-1]=2.2
+\, and y3[-1]=0.4;
+#X msg 244 475 set 4000;
+#X obj 125 504 sig~ 0.001;
+#X msg 245 498 clear;
+#X text 22 442 comment;
+#X text 14 431 1 first click the start button;
+#X text 307 494 2 click the set or the clear button;
+#X text 304 547 3 then click bang to see how set and clear work;
+#X connect 4 0 42 0;
+#X connect 5 0 11 1;
+#X connect 6 0 5 0;
+#X connect 9 0 8 0;
+#X connect 10 0 74 0;
+#X connect 11 0 20 0;
+#X connect 11 0 20 1;
+#X connect 12 0 8 0;
+#X connect 13 0 24 0;
+#X connect 14 0 16 1;
+#X connect 16 0 15 0;
+#X connect 16 0 15 1;
+#X connect 17 0 18 0;
+#X connect 18 0 14 0;
+#X connect 19 0 18 0;
+#X connect 23 0 18 0;
+#X connect 24 0 16 0;
+#X connect 25 0 13 0;
+#X connect 26 0 18 0;
+#X connect 27 0 18 0;
+#X connect 28 0 18 0;
+#X connect 29 0 13 0;
+#X connect 30 0 16 0;
+#X connect 31 0 16 0;
+#X connect 32 0 11 0;
+#X connect 33 0 11 0;
+#X connect 34 0 12 0;
+#X connect 35 0 12 0;
+#X connect 36 0 31 0;
+#X connect 37 0 35 0;
+#X connect 38 0 33 0;
+#X connect 41 0 5 0;
+#X connect 42 0 11 0;
+#X connect 43 0 4 0;
+#X connect 44 0 4 0;
+#X connect 45 0 5 0;
+#X connect 73 0 12 0;
+#X connect 74 0 12 0;
+#X connect 75 0 12 0;
+#X restore 306 472 pd examples of fexpr~;
+#X text 42 504 For using fexpr~ for solving;
+#X text 43 520 differential equations click here ->;
+#N canvas 112 22 944 449 lorenz 0;
+#X obj 176 67 v pr;
+#X obj 307 68 v r;
+#X obj 233 69 v b;
+#X floatatom 176 38 5 0 0;
+#X floatatom 307 40 5 0 0;
+#X msg 177 13 10;
+#X obj 231 10 expr 8./3;
+#X msg 128 136 set 1.2 2.3 4.4;
+#X floatatom 233 39 7 0 0;
+#X msg 75 46 stop;
+#X msg 75 67 start;
+#X floatatom 399 40 5 0 0;
+#X obj 399 69 v dt;
+#X msg 310 12 18;
+#X msg 395 13 0.01;
+#X obj 68 296 dac~;
+#X obj 128 -41 bng 15 250 50 0 empty empty empty 20 8 0 8 -262144 -1
+-1;
+#X text 201 -41 <- turn audio on and bang here;
+#X text 463 42 <- experiment with these numbers;
+#X text 472 72 if you hear a buzz \, you have probably gone unstable
+bang on the top again;
+#X obj 489 15 line;
+#X obj 128 241 /~ 20;
+#X obj 234 238 /~ 20;
+#X obj 340 237 /~ 20;
+#X msg 484 -11 0.01 \, 0.04 5000;
+#X obj 128 185 fexpr~ $y1+(pr*$y2-pr*$y1)*dt \; $y2 +(-$y1*$y3 + r*$y1-$y2)*dt
+\; $y3+($y1*$y2 - b*$y3)*dt;
+#X obj 14 65 loadbang;
+#X text 113 -100 This is an example of how fexpr~ could be used for
+solving differential equations \, in this case the lorenz equations
+which generate chotic signals;
+#X text 361 182 Note the following shorthands:;
+#X text 360 198 $y1 -> $y1[-1] \, $y2 -> $y2[-1] \, .....;
+#X text 248 136 the 'set' commands sets the initial previous values
+;
+#X obj 128 298 tabsend~ lorenz1a;
+#X obj 234 278 tabsend~ lorenz2a;
+#X obj 339 259 tabsend~ lorenz3a;
+#N canvas 0 0 450 300 graph1 0;
+#X array lorenz1a 64 float 0;
+#X coords 0 1 63 -1 200 140 1;
+#X restore 73 437 graph;
+#N canvas 0 0 450 300 graph2 0;
+#X array lorenz2a 64 float 0;
+#X coords 0 1 63 -1 200 140 1;
+#X restore 331 435 graph;
+#N canvas 0 0 450 300 graph3 0;
+#X array lorenz3a 64 float 0;
+#X coords 0 1 63 -1 200 140 1;
+#X restore 592 436 graph;
+#X text 301 315 You can see the graphs if you scroll down;
+#X text 301 328 but the redrawings may cause clicks in the audio;
+#X connect 3 0 0 0;
+#X connect 4 0 1 0;
+#X connect 5 0 3 0;
+#X connect 6 0 8 0;
+#X connect 7 0 25 0;
+#X connect 8 0 2 0;
+#X connect 9 0 25 0;
+#X connect 10 0 25 0;
+#X connect 11 0 12 0;
+#X connect 13 0 4 0;
+#X connect 14 0 11 0;
+#X connect 16 0 5 0;
+#X connect 16 0 6 0;
+#X connect 16 0 13 0;
+#X connect 16 0 14 0;
+#X connect 16 0 7 0;
+#X connect 16 0 10 0;
+#X connect 20 0 11 0;
+#X connect 21 0 31 0;
+#X connect 21 0 15 0;
+#X connect 21 0 15 1;
+#X connect 22 0 32 0;
+#X connect 23 0 33 0;
+#X connect 24 0 20 0;
+#X connect 25 0 21 0;
+#X connect 25 1 22 0;
+#X connect 25 2 23 0;
+#X connect 26 0 9 0;
+#X restore 308 518 pd lorenz equations for audition;
+#N canvas 97 36 978 656 lorenz 0;
+#X obj 176 67 v pr;
+#X obj 307 68 v r;
+#X obj 233 69 v b;
+#X floatatom 176 38 5 0 0;
+#X floatatom 307 40 5 0 0;
+#X msg 177 13 10;
+#X obj 231 10 expr 8./3;
+#N canvas 0 0 450 300 graph1 0;
+#X array lorenz1 2048 float 0;
+#X coords 0 -1 2047 1 200 140 1;
+#X restore 82 357 graph;
+#N canvas 0 0 450 300 graph2 0;
+#X array lorenz2 2048 float 0;
+#X coords 0 -1 2047 1 200 140 1;
+#X restore 327 353 graph;
+#N canvas 0 0 450 300 graph3 0;
+#X array lorenz3 2048 float 0;
+#X coords 0 -1 2047 1 200 140 1;
+#X restore 570 347 graph;
+#X msg 128 136 set 1.2 2.3 4.4;
+#X floatatom 233 39 7 0 0;
+#X msg 75 46 stop;
+#X msg 75 67 start;
+#X floatatom 399 40 5 0 0;
+#X obj 399 69 v dt;
+#X msg 310 12 18;
+#X msg 395 13 0.01;
+#X obj 128 -41 bng 15 250 50 0 empty empty empty 20 8 0 8 -262144 -1
+-1;
+#X text 201 -41 <- turn audio on and bang here;
+#X text 463 42 <- experiment with these numbers;
+#X text 472 72 if you hear a buzz \, you have probably gone unstable
+bang on the top again;
+#X obj 489 15 line;
+#X obj 128 241 /~ 20;
+#X obj 234 238 /~ 20;
+#X obj 340 237 /~ 20;
+#X msg 484 -11 0.01 \, 0.04 5000;
+#X obj 14 65 loadbang;
+#X text 113 -100 This is an example of how fexpr~ could be used for
+solving differential equations \, in this case the lorenz equations
+which generate chotic signals;
+#X text 361 182 Note the following shorthands:;
+#X text 360 198 $y1 -> $y1[-1] \, $y2 -> $y2[-1] \, .....;
+#X text 248 136 the 'set' commands sets the initial previous values
+;
+#X obj 128 298 tabsend~ lorenz1;
+#X obj 234 278 tabsend~ lorenz2;
+#X obj 339 259 tabsend~ lorenz3;
+#X obj 627 280 block~ 2048;
+#X text 669 133 Lorenz Equations;
+#X obj 128 185 fexpr~ $y1+pr * ($y2-$y1)*dt \; $y2 +(-$y1*$y3 + r*$y1-$y2)*dt
+\; $y3+($y1*$y2 - b*$y3)*dt;
+#X text 672 197 dZ/dt = -bZ;
+#X text 669 167 dX/dt = pr * (X - Y);
+#X text 668 147 written with 3 state variable X \, Y \, and Z;
+#X text 670 182 dY/dt = -XZ + rX - y;
+#X connect 3 0 0 0;
+#X connect 4 0 1 0;
+#X connect 5 0 3 0;
+#X connect 6 0 11 0;
+#X connect 10 0 37 0;
+#X connect 11 0 2 0;
+#X connect 12 0 37 0;
+#X connect 13 0 37 0;
+#X connect 14 0 15 0;
+#X connect 16 0 4 0;
+#X connect 17 0 14 0;
+#X connect 18 0 5 0;
+#X connect 18 0 6 0;
+#X connect 18 0 16 0;
+#X connect 18 0 17 0;
+#X connect 18 0 10 0;
+#X connect 18 0 13 0;
+#X connect 22 0 14 0;
+#X connect 23 0 32 0;
+#X connect 24 0 33 0;
+#X connect 25 0 34 0;
+#X connect 26 0 22 0;
+#X connect 27 0 12 0;
+#X connect 37 0 23 0;
+#X connect 37 1 24 0;
+#X connect 37 2 25 0;
+#X restore 308 541 pd lorenz equations for visualization;
+#X text 68 24 by Shahrokh Yadegari;
diff --git a/desiredata/extra/help-hilbert~.pd b/desiredata/extra/help-hilbert~.pd
new file mode 100644
index 00000000..130ec750
--- /dev/null
+++ b/desiredata/extra/help-hilbert~.pd
@@ -0,0 +1,18 @@
+#N canvas 156 234 600 488 12;
+#X obj 67 124 hilbert~;
+#X obj 66 85 osc~ 440;
+#X graph graph1 0 -1 882 1 279 209 579 39;
+#X array out-left 882 float;
+#X array out-right 882 float;
+#X pop;
+#X obj 67 274 tabwrite~ out-left;
+#X obj 118 248 tabwrite~ out-right;
+#X msg 137 188 bang \; pd dsp 1;
+#X floatatom 66 57;
+#X text 71 319 The Hilbert transform (the name is abused here according to computer music tradition) puts out a phase quadrature version of the input signal suitable for signal sideband modulation via complex-mod~.;
+#X connect 0 0 3 0;
+#X connect 0 1 4 0;
+#X connect 1 0 0 0;
+#X connect 5 0 3 0;
+#X connect 5 0 4 0;
+#X connect 6 0 1 0;
diff --git a/desiredata/extra/help-rev1~.pd b/desiredata/extra/help-rev1~.pd
new file mode 100644
index 00000000..55580bd5
--- /dev/null
+++ b/desiredata/extra/help-rev1~.pd
@@ -0,0 +1,119 @@
+#N canvas 55 21 1008 526 12;
+#X obj 148 439 dac~;
+#X obj 58 72 line~;
+#X msg 58 49 0 \, 10000 5;
+#X obj 58 118 cos~;
+#X msg 146 70 1;
+#X obj 146 47 loadbang;
+#X obj 58 95 clip~ 0 0.25;
+#X floatatom 173 264 0 0 0;
+#X obj 251 134 line~;
+#X obj 251 157 cos~;
+#X msg 324 54 -0.25 \, 0.25 100;
+#X obj 251 8 loadbang;
+#X msg 251 31 -0.25;
+#X obj 251 203 *~;
+#X obj 58 140 hip~ 5;
+#X floatatom 162 328 0 0 0;
+#X obj 162 373 pack 0 100;
+#X obj 162 396 line~;
+#X obj 148 416 *~;
+#X obj 162 350 dbtorms;
+#X msg 324 77 -0.25 \, 0.25 400;
+#X floatatom 324 145 0 0 0;
+#X obj 324 191 osc~ 440;
+#X obj 324 168 mtof;
+#X msg 324 31 -0.25 \, 0.25 20;
+#X obj 251 180 *~ 0.1;
+#X msg 324 100 -0.25 \, 0.25 1000;
+#X msg 324 122 -0.25 \, 0.25 2000;
+#X obj 324 226 *~;
+#X obj 342 252 *~;
+#X obj 58 439 dac~;
+#X floatatom 68 323 0 0 0;
+#X obj 68 368 pack 0 100;
+#X obj 68 391 line~;
+#X obj 58 416 *~;
+#X obj 68 346 dbtorms;
+#X msg 324 8 0;
+#X obj 308 257 *~;
+#X obj 58 26 metro 2000;
+#X floatatom 58 4 0 0 0;
+#X msg 220 265 bang;
+#X obj 284 322 env~ 32768;
+#X floatatom 284 344 0 0 0;
+#X text 166 244 1 sec;
+#X text 143 226 dB after;
+#X text 220 245 clear;
+#X text 1 51 impulse;
+#X text 362 7 tone;
+#X text 484 31 beeps;
+#X text 428 167 This is an experimental reverberator design composed
+of a series of allpass filters with exponentially growing delay times.
+Each allpass filter has a gain of 0.7. The reverb time is adjusted
+by adjusting the input gains of the allpass filters. The last unit
+is modified so that its first two "echos" mimic those of an allpass
+but its loop gain depends on reverb time.;
+#X text 430 299 Reverb time is controlled by specifying the dB gain
+(100 normal) after one second \, so that 100 corresponds to infinite
+reverb time \, 70 to two seconds \, 40 to one second \, and 0 to 0
+;
+#X text 671 499 modified for Pd version 0.30.;
+#X msg 560 34 \; pd dsp 1;
+#X text 427 475 The rev1~ module eats about 18% of my 300mHz P2 machine.
+;
+#X obj 148 289 rev1~;
+#X text 428 381 The "clear" button impolitely clears out all the delay
+lines \, You may immediately resume pumping the reverberator \, but
+the input signal should be cleanly enveloped. The output \, too \,
+must be enveloped and may not be opened until 5 msec after the "clear"
+message is sent.;
+#X connect 1 0 6 0;
+#X connect 2 0 1 0;
+#X connect 3 0 14 0;
+#X connect 4 0 1 0;
+#X connect 5 0 4 0;
+#X connect 6 0 3 0;
+#X connect 7 0 54 1;
+#X connect 8 0 9 0;
+#X connect 9 0 25 0;
+#X connect 10 0 8 0;
+#X connect 11 0 12 0;
+#X connect 12 0 8 0;
+#X connect 13 0 14 0;
+#X connect 14 0 34 0;
+#X connect 14 0 54 0;
+#X connect 15 0 19 0;
+#X connect 16 0 17 0;
+#X connect 17 0 18 1;
+#X connect 18 0 0 0;
+#X connect 19 0 16 0;
+#X connect 20 0 8 0;
+#X connect 21 0 23 0;
+#X connect 22 0 13 1;
+#X connect 22 0 28 0;
+#X connect 22 0 28 1;
+#X connect 22 0 29 0;
+#X connect 23 0 22 0;
+#X connect 24 0 8 0;
+#X connect 25 0 13 0;
+#X connect 26 0 8 0;
+#X connect 27 0 8 0;
+#X connect 28 0 29 1;
+#X connect 28 0 13 1;
+#X connect 28 0 37 0;
+#X connect 28 0 37 1;
+#X connect 29 0 13 1;
+#X connect 31 0 35 0;
+#X connect 32 0 33 0;
+#X connect 33 0 34 1;
+#X connect 34 0 30 0;
+#X connect 35 0 32 0;
+#X connect 36 0 8 0;
+#X connect 37 0 13 1;
+#X connect 38 0 2 0;
+#X connect 39 0 38 0;
+#X connect 40 0 54 2;
+#X connect 41 0 42 0;
+#X connect 54 0 18 0;
+#X connect 54 0 41 0;
diff --git a/desiredata/extra/help-rev2~.pd b/desiredata/extra/help-rev2~.pd
new file mode 100644
index 00000000..8f9fbaaf
--- /dev/null
+++ b/desiredata/extra/help-rev2~.pd
@@ -0,0 +1,134 @@
+#N canvas 167 160 766 354 12;
+#X floatatom 73 185 0 0 120 0 - - -;
+#X floatatom 106 323 0 0 120 0 - - -;
+#N canvas 0 0 539 448 tests 0;
+#X obj 67 33 inlet;
+#X obj 309 189 inlet;
+#X obj 235 207 line~;
+#X obj 235 230 cos~;
+#X obj 235 68 loadbang;
+#X msg 235 91 -0.25;
+#X obj 235 276 *~;
+#X obj 186 309 hip~ 5;
+#X floatatom 308 218 0 0 0 0 - - -;
+#X obj 308 264 osc~ 440;
+#X obj 308 241 mtof;
+#X obj 235 253 *~ 0.1;
+#X obj 308 299 *~;
+#X obj 326 325 *~;
+#X obj 292 330 *~;
+#X msg 279 150 -0.25 \, 0.25 \$1;
+#X obj 41 148 biquad~ 0 0 1 -1 0;
+#X obj 63 70 t b;
+#X obj 104 72 del 3;
+#X obj 57 101 1;
+#X obj 96 101 0;
+#X obj 41 355 outlet~;
+#X obj 279 126 inlet;
+#X obj 40 175 *~;
+#X connect 0 0 17 0;
+#X connect 1 0 8 0;
+#X connect 2 0 3 0;
+#X connect 3 0 11 0;
+#X connect 4 0 5 0;
+#X connect 5 0 2 0;
+#X connect 6 0 7 0;
+#X connect 7 0 21 0;
+#X connect 8 0 10 0;
+#X connect 9 0 6 1;
+#X connect 9 0 12 0;
+#X connect 9 0 12 1;
+#X connect 9 0 13 0;
+#X connect 10 0 9 0;
+#X connect 11 0 6 0;
+#X connect 12 0 13 1;
+#X connect 12 0 6 1;
+#X connect 12 0 14 0;
+#X connect 12 0 14 1;
+#X connect 13 0 6 1;
+#X connect 14 0 6 1;
+#X connect 15 0 2 0;
+#X connect 16 0 23 0;
+#X connect 17 0 18 0;
+#X connect 17 0 19 0;
+#X connect 18 0 20 0;
+#X connect 19 0 16 0;
+#X connect 19 0 23 1;
+#X connect 20 0 16 0;
+#X connect 20 0 23 1;
+#X connect 22 0 15 0;
+#X connect 23 0 21 0;
+#X restore 17 154 pd tests;
+#X msg 56 35 10;
+#X msg 54 62 20;
+#X msg 53 90 100;
+#X msg 52 115 500;
+#X obj 17 15 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 37 9 impulse;
+#N canvas 0 0 450 300 output 0;
+#X obj 54 202 dac~;
+#X obj 132 119 pack 0 100;
+#X obj 132 142 line~;
+#X obj 54 165 *~;
+#X obj 132 97 dbtorms;
+#X obj 33 42 inlet~;
+#X obj 177 42 inlet;
+#X obj 177 74 clip 0 120;
+#X msg 257 133 \; pd dsp 1;
+#X obj 98 42 inlet~;
+#X obj 94 168 *~;
+#X connect 1 0 2 0;
+#X connect 2 0 3 1;
+#X connect 2 0 10 1;
+#X connect 3 0 0 0;
+#X connect 4 0 1 0;
+#X connect 5 0 3 0;
+#X connect 6 0 7 0;
+#X connect 6 0 8 0;
+#X connect 7 0 4 0;
+#X connect 9 0 10 0;
+#X connect 10 0 0 1;
+#X restore 18 324 pd output;
+#X floatatom 97 127 0 0 0 0 - - -;
+#X text 136 96 tone;
+#X text 135 112 pitch;
+#X text 114 185 level \, dB;
+#X floatatom 117 209 0 0 100 0 - - -;
+#X text 158 209 liveness \, 0-100;
+#X text 505 330 modified for Pd version 0.37;
+#X floatatom 161 235 0 0 120 0 - - -;
+#X floatatom 205 259 0 0 120 0 - - -;
+#X text 192 235 crossover frequency \, Hz.;
+#X text 238 260 HF damping \, percent;
+#X obj 30 290 rev2~ 100 90 3000 20;
+#X text 141 324 output level \, dB;
+#X text 281 8 REV2~ - a simple 1-in \, 4-out reverberator;
+#X text 95 35 tone;
+#X text 96 52 bursts;
+#X text 231 37 The creation arguments (level \, liveness \, crossover
+frequency \, HF damping) may also be supplied in four inlets as shown.
+The "liveness" (actually the internal feedback percentage) should be
+100 for infinite reverb \, 90 for longish \, and 80 for short. The
+crossover frequency and HF damping work together: at frequencies above
+crossover \, the feedback is diminished by the "damping" as a percentage.
+So zero HF damping means equal reverb time at all frequencies \, and
+100% damping means almost nothing above the crossover frequency gets
+through.;
+#X text 132 130 (60 for;
+#X text 115 150 middle C);
+#X connect 0 0 21 1;
+#X connect 1 0 9 2;
+#X connect 2 0 9 0;
+#X connect 2 0 21 0;
+#X connect 3 0 2 1;
+#X connect 4 0 2 1;
+#X connect 5 0 2 1;
+#X connect 6 0 2 1;
+#X connect 7 0 2 0;
+#X connect 10 0 2 2;
+#X connect 14 0 21 2;
+#X connect 17 0 21 3;
+#X connect 18 0 21 4;
+#X connect 21 0 9 0;
+#X connect 21 1 9 1;
diff --git a/desiredata/extra/help-rev3~.pd b/desiredata/extra/help-rev3~.pd
new file mode 100644
index 00000000..78ef15f5
--- /dev/null
+++ b/desiredata/extra/help-rev3~.pd
@@ -0,0 +1,136 @@
+#N canvas 70 263 765 380 12;
+#X floatatom 99 212 0 0 120 0 - - -;
+#X floatatom 105 340 0 0 120 0 - - -;
+#N canvas 0 0 539 448 tests 0;
+#X obj 67 33 inlet;
+#X obj 309 189 inlet;
+#X obj 235 207 line~;
+#X obj 235 230 cos~;
+#X obj 235 68 loadbang;
+#X msg 235 91 -0.25;
+#X obj 235 276 *~;
+#X obj 186 309 hip~ 5;
+#X floatatom 308 218 0 0 0 0 - - -;
+#X obj 308 264 osc~ 440;
+#X obj 308 241 mtof;
+#X obj 235 253 *~ 0.1;
+#X obj 308 299 *~;
+#X obj 326 325 *~;
+#X obj 292 330 *~;
+#X msg 279 150 -0.25 \, 0.25 \$1;
+#X obj 41 148 biquad~ 0 0 1 -1 0;
+#X obj 63 70 t b;
+#X obj 104 72 del 3;
+#X obj 57 101 1;
+#X obj 96 101 0;
+#X obj 41 355 outlet~;
+#X obj 279 126 inlet;
+#X obj 51 192 *~;
+#X connect 0 0 17 0;
+#X connect 1 0 8 0;
+#X connect 2 0 3 0;
+#X connect 3 0 11 0;
+#X connect 4 0 5 0;
+#X connect 5 0 2 0;
+#X connect 6 0 7 0;
+#X connect 7 0 21 0;
+#X connect 8 0 10 0;
+#X connect 9 0 6 1;
+#X connect 9 0 12 0;
+#X connect 9 0 12 1;
+#X connect 9 0 13 0;
+#X connect 10 0 9 0;
+#X connect 11 0 6 0;
+#X connect 12 0 13 1;
+#X connect 12 0 6 1;
+#X connect 12 0 14 0;
+#X connect 12 0 14 1;
+#X connect 13 0 6 1;
+#X connect 14 0 6 1;
+#X connect 15 0 2 0;
+#X connect 16 0 23 0;
+#X connect 17 0 18 0;
+#X connect 17 0 19 0;
+#X connect 18 0 20 0;
+#X connect 19 0 16 0;
+#X connect 19 0 23 1;
+#X connect 20 0 16 0;
+#X connect 20 0 23 1;
+#X connect 22 0 15 0;
+#X connect 23 0 21 0;
+#X restore 16 171 pd tests;
+#X msg 55 52 10;
+#X msg 53 79 20;
+#X msg 52 107 100;
+#X msg 51 132 500;
+#X obj 16 32 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 36 26 impulse;
+#N canvas 0 0 450 300 output 0;
+#X obj 54 202 dac~;
+#X obj 132 119 pack 0 100;
+#X obj 132 142 line~;
+#X obj 54 165 *~;
+#X obj 132 97 dbtorms;
+#X obj 33 42 inlet~;
+#X obj 177 42 inlet;
+#X obj 177 74 clip 0 120;
+#X msg 257 133 \; pd dsp 1;
+#X obj 98 42 inlet~;
+#X obj 94 168 *~;
+#X connect 1 0 2 0;
+#X connect 2 0 3 1;
+#X connect 2 0 10 1;
+#X connect 3 0 0 0;
+#X connect 4 0 1 0;
+#X connect 5 0 3 0;
+#X connect 6 0 7 0;
+#X connect 6 0 8 0;
+#X connect 7 0 4 0;
+#X connect 9 0 10 0;
+#X connect 10 0 0 1;
+#X restore 17 340 pd output;
+#X floatatom 96 144 0 0 0 0 - - -;
+#X text 135 113 tone;
+#X text 134 129 pitch;
+#X text 140 212 level \, dB;
+#X floatatom 134 234 0 0 100 0 - - -;
+#X text 175 234 liveness \, 0-100;
+#X floatatom 169 258 4 0 5000 0 - - -;
+#X floatatom 204 281 0 0 100 0 - - -;
+#X text 217 256 crossover frequency \, Hz.;
+#X text 240 283 HF damping \, percent;
+#X text 140 341 output level \, dB;
+#X text 94 52 tone;
+#X text 95 69 bursts;
+#X text 131 147 (60 for;
+#X text 114 167 middle C);
+#X obj 29 307 rev3~ 100 90 3000 20;
+#X text 263 4 REV3~ - hard-core \, 2-in \, 4-out reverberator;
+#X text 236 56 The creation arguments (level \, liveness \, crossover
+frequency \, HF damping) may also be supplied in four inlets as shown.
+The "liveness" (actually the internal feedback percentage) should be
+100 for infinite reverb \, 90 for longish \, and 80 for short. The
+crossover frequency and HF damping work together: at frequencies above
+crossover \, the feedback is diminished by the "damping" as a percentage.
+So zero HF damping means equal reverb time at all frequencies \, and
+100% damping means almost nothing above the crossover frequency gets
+through.;
+#X text 236 29 (A more expensive \, presumably better \, one than rev2~.)
+;
+#X text 470 352 modified for Pd version 0.37-1;
+#X connect 0 0 25 2;
+#X connect 1 0 9 2;
+#X connect 2 0 9 0;
+#X connect 2 0 25 0;
+#X connect 3 0 2 1;
+#X connect 4 0 2 1;
+#X connect 5 0 2 1;
+#X connect 6 0 2 1;
+#X connect 7 0 2 0;
+#X connect 10 0 2 2;
+#X connect 14 0 25 3;
+#X connect 16 0 25 4;
+#X connect 17 0 25 5;
+#X connect 25 0 9 0;
+#X connect 25 1 9 1;
diff --git a/desiredata/extra/hilbert~.pd b/desiredata/extra/hilbert~.pd
new file mode 100644
index 00000000..5bc7a550
--- /dev/null
+++ b/desiredata/extra/hilbert~.pd
@@ -0,0 +1,15 @@
+#N canvas 451 128 556 360 12;
+#X obj 117 129 biquad~ 0.83774 -0.06338 0.06338 -0.83774 1;
+#X obj 117 103 biquad~ 1.94632 -0.94657 0.94657 -1.94632 1;
+#X obj 98 186 biquad~ -0.02569 0.260502 -0.260502 0.02569 1;
+#X obj 98 212 biquad~ 1.8685 -0.870686 0.870686 -1.8685 1;
+#X obj 98 76 inlet~;
+#X obj 117 158 outlet~;
+#X obj 98 239 outlet~;
+#X text 105 273 This is a pair of all-pass filters whose outputs somehow manage to be about 90 degrees out of phase from each other. I don't know what phase relation they have with the original signal. I adapted this from a 4X patch by Emmanuel Favreau \, circa 1982;
+#X connect 0 0 5 0;
+#X connect 1 0 0 0;
+#X connect 2 0 3 0;
+#X connect 3 0 6 0;
+#X connect 4 0 1 0;
+#X connect 4 0 2 0;
diff --git a/desiredata/extra/loop~/loop~.c b/desiredata/extra/loop~/loop~.c
new file mode 100644
index 00000000..2f440030
--- /dev/null
+++ b/desiredata/extra/loop~/loop~.c
@@ -0,0 +1,164 @@
+/* loop~ -- loop generator for sampling */
+
+/*  Copyright 1997-1999 Miller Puckette.
+Permission is granted to use this software for any purpose provided you
+keep this copyright notice intact.
+
+THE AUTHOR AND HIS EMPLOYERS MAKE NO WARRANTY, EXPRESS OR IMPLIED,
+IN CONNECTION WITH THIS SOFTWARE.
+
+This file is downloadable from http://www.crca.ucsd.edu/~msp .
+
+*/
+
+#ifdef PD
+#include "m_pd.h"
+#endif
+
+typedef struct _loopctl
+{
+    double l_phase;
+    float l_invwindow;
+    float l_window;
+    int l_resync;
+} t_loopctl;
+
+static void loopctl_run(t_loopctl *x, float *transposein,
+        float *windowin, float *rawout, float *windowout, int n)
+{
+    float window, invwindow;
+    double phase = x->l_phase;
+    if (x->l_resync)
+    {
+        window = *windowin;
+        if (window < 0)
+        {
+            if (window > -1)
+                window = -1;
+            invwindow = -1/window;
+        }
+        else
+        {
+            if (window < 1)
+                window = 1;
+            invwindow = 1/window;
+        }
+        x->l_resync = 0;
+    }
+    else
+    {
+        window = x->l_window;
+        phase = x->l_phase;
+        invwindow = x->l_invwindow;
+    }
+    while (n--)
+    {
+        double phaseinc = invwindow * *transposein++;
+        double newphase;
+        float nwind = *windowin++;
+        if (phaseinc >= 1 || phaseinc < 0)
+            phaseinc = 0;
+        newphase = phase + phaseinc;
+        if (newphase >= 1)
+        {
+            window = nwind;
+            if (window < 0)
+            {
+                if (window > -1)
+                    window = -1;
+                invwindow = -1/window;
+            }
+            else
+            {
+                if (window < 1)
+                    window = 1;
+                invwindow = 1/window;
+            }
+            newphase -= 1.;
+        }
+        phase = newphase;
+        *rawout++ = (float)phase;
+        *windowout++ = window;
+    }
+    x->l_invwindow = invwindow;
+    x->l_window = window;
+    x->l_phase = phase;
+}
+
+static void loopctl_init(t_loopctl *x)
+{
+    x->l_window = 1;
+    x->l_invwindow = 1;
+    x->l_phase = 0;
+}
+
+static void loopctl_set(t_loopctl *x, float val)
+{
+    if (val < 0 || val > 1)
+        val = 0;
+    x->l_phase = val;
+    x->l_resync = 1;
+}
+
+#ifdef PD
+
+typedef struct _loop
+{
+    t_object x_obj;
+    t_float x_f;
+    t_loopctl x_loopctl;
+} t_loop;
+
+static t_class *loop_class;
+
+static void *loop_new(void)
+{
+    t_loop *x = (t_loop *)pd_new(loop_class);
+    loopctl_init(&x->x_loopctl);
+    inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
+    outlet_new(&x->x_obj, gensym("signal"));
+    outlet_new(&x->x_obj, gensym("signal"));
+    return (x);
+}
+
+static t_int *loop_perform(t_int *w)
+{
+    t_loopctl *ctl = (t_loopctl *)(w[1]);
+    t_float *in1 = (t_float *)(w[2]);
+    t_float *in2 = (t_float *)(w[3]);
+    t_float *out1 = (t_float *)(w[4]);
+    t_float *out2 = (t_float *)(w[5]);
+    int n = (int)(w[6]);
+    loopctl_run(ctl, in1, in2, out1, out2, n);
+    return (w+7);
+}
+
+static void loop_dsp(t_loop *x, t_signal **sp)
+{
+    dsp_add(loop_perform, 6,
+        &x->x_loopctl, sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[3]->s_vec,
+            sp[0]->s_n);
+}
+
+static void loop_set(t_loop *x, t_floatarg val)
+{
+    loopctl_set(&x->x_loopctl, val);
+}
+
+static void loop_bang(t_loop *x)
+{
+    loopctl_set(&x->x_loopctl, 0);
+}
+
+void loop_tilde_setup(void)
+{
+    loop_class = class_new(gensym("loop~"), (t_newmethod)loop_new, 0,
+        sizeof(t_loop), 0, 0);
+    class_addmethod(loop_class, (t_method)loop_dsp, gensym("dsp"), A_CANT, 0);
+    CLASS_MAINSIGNALIN(loop_class, t_loop, x_f);
+    class_addmethod(loop_class, (t_method)loop_set, gensym("set"),
+        A_DEFFLOAT, 0);
+    class_addbang(loop_class, loop_bang);
+}
+
+#endif /* PD */
diff --git a/desiredata/extra/loop~/makefile b/desiredata/extra/loop~/makefile
new file mode 100644
index 00000000..fd21f2b4
--- /dev/null
+++ b/desiredata/extra/loop~/makefile
@@ -0,0 +1,4 @@
+NAME=loop~
+CSYM=loop_tilde
+
+include ../makefile
diff --git a/desiredata/extra/loop~/test-loop~.pd b/desiredata/extra/loop~/test-loop~.pd
new file mode 100644
index 00000000..9966483d
--- /dev/null
+++ b/desiredata/extra/loop~/test-loop~.pd
@@ -0,0 +1,58 @@
+#N canvas 33 0 680 609 12;
+#X floatatom 52 262 0 0 0 0 - - -;
+#X obj 261 346 print~;
+#X msg 47 373 bang;
+#X msg 274 313 bang;
+#X obj 52 306 loop~;
+#X floatatom 102 245 0 0 0 0 - - -;
+#N canvas 0 0 450 300 graph1 0;
+#X array array1 44100 float 0;
+#X coords 0 10 44100 0 200 150 1;
+#X restore 65 17 graph;
+#X msg 43 204 \; array1 resize 44100;
+#X obj 25 401 tabwrite~ array1;
+#X msg 208 371 bang;
+#X obj 176 402 tabwrite~ array1;
+#X msg 194 261 bang;
+#X obj 204 347 print~;
+#X msg 217 314 bang;
+#N canvas 0 0 450 300 graph1 0;
+#X array array2 150000 float 0;
+#X coords 0 1 150000 -1 200 150 1;
+#X restore 332 398 graph;
+#X msg 326 274 \; array2 resize 150000;
+#X obj 103 529 tabread4~ array2;
+#X obj 64 481 *~;
+#X obj 107 581 dac~;
+#X obj 105 552 hip~ 5;
+#X obj 123 482 samphold~;
+#X obj 102 506 +~;
+#X floatatom 106 430 0 0 0 0 - - -;
+#X obj 108 453 *~ 1000;
+#X obj 312 215 soundfiler;
+#X msg 330 170 read ../doc/sound/bell.aiff array2;
+#X msg 330 193 read ../doc/sound/vocal.aiff array2;
+#X connect 0 0 4 0;
+#X connect 2 0 8 0;
+#X connect 3 0 1 0;
+#X connect 4 0 12 0;
+#X connect 4 0 17 0;
+#X connect 4 0 8 0;
+#X connect 4 0 20 1;
+#X connect 4 1 10 0;
+#X connect 4 1 1 0;
+#X connect 4 1 17 1;
+#X connect 5 0 4 1;
+#X connect 9 0 10 0;
+#X connect 11 0 4 0;
+#X connect 13 0 12 0;
+#X connect 16 0 19 0;
+#X connect 17 0 21 0;
+#X connect 19 0 18 0;
+#X connect 19 0 18 1;
+#X connect 20 0 21 1;
+#X connect 21 0 16 0;
+#X connect 22 0 23 0;
+#X connect 23 0 20 0;
+#X connect 25 0 24 0;
+#X connect 26 0 24 0;
diff --git a/desiredata/extra/lrshift~/lrshift~.c b/desiredata/extra/lrshift~/lrshift~.c
new file mode 100644
index 00000000..ba1d5eeb
--- /dev/null
+++ b/desiredata/extra/lrshift~/lrshift~.c
@@ -0,0 +1,74 @@
+#include "m_pd.h"
+
+/* ------------------------ lrshift~ ----------------------------- */
+
+static t_class *lrshift_tilde_class;
+
+typedef struct _lrshift_tilde
+{
+    t_object x_obj;
+    int x_n;
+} t_lrshift_tilde;
+
+static t_int *leftshift_perform(t_int *w)
+{
+    t_float *in = (t_float *)(w[1]);
+    t_float *out= (t_float *)(w[2]);
+    int n = (int)(w[3]);
+    int shift = (int)(w[4]);
+    in += shift;
+    n -= shift;
+    while (n--)
+        *out++ = *in++;
+    while (shift--)
+        *out++ = 0;
+    return (w+5);
+}
+
+static t_int *rightshift_perform(t_int *w)
+{
+    t_float *in = (t_float *)(w[1]);
+    t_float *out= (t_float *)(w[2]);
+    int n = (int)(w[3]);
+    int shift = (int)(w[4]);
+    n -= shift;
+    in -= shift;
+    while (n--)
+        *--out = *--in;
+    while (shift--)
+        *--out = 0;
+    return (w+5);
+}
+
+static void lrshift_tilde_dsp(t_lrshift_tilde *x, t_signal **sp)
+{
+    int n = sp[0]->s_n;
+    int shift = x->x_n;
+    if (shift > n)
+        shift = n;
+    if (shift < -n)
+        shift = -n;
+    if (shift < 0)
+        dsp_add(rightshift_perform, 4,
+            sp[0]->s_vec + n, sp[1]->s_vec + n, n, -shift);
+    else dsp_add(leftshift_perform, 4,
+            sp[0]->s_vec, sp[1]->s_vec, n, shift);
+}
+
+static void *lrshift_tilde_new(t_floatarg f)
+{
+    t_lrshift_tilde *x = (t_lrshift_tilde *)pd_new(lrshift_tilde_class);
+    x->x_n = f;
+    outlet_new(&x->x_obj, gensym("signal"));
+    return (x);
+}
+
+void lrshift_tilde_setup(void)
+{
+    lrshift_tilde_class = class_new(gensym("lrshift~"),
+        (t_newmethod)lrshift_tilde_new, 0, sizeof(t_lrshift_tilde), 0, 
+            A_DEFFLOAT, 0);
+    class_addmethod(lrshift_tilde_class, nullfn, gensym("signal"), 0);
+    class_addmethod(lrshift_tilde_class, (t_method)lrshift_tilde_dsp,
+        gensym("dsp"), 0);
+}
diff --git a/desiredata/extra/lrshift~/makefile b/desiredata/extra/lrshift~/makefile
new file mode 100644
index 00000000..d6a24cfe
--- /dev/null
+++ b/desiredata/extra/lrshift~/makefile
@@ -0,0 +1,4 @@
+NAME=lrshift~
+CSYM=lrshift_tilde
+
+include ../makefile
diff --git a/desiredata/extra/makefile b/desiredata/extra/makefile
new file mode 100644
index 00000000..a328d919
--- /dev/null
+++ b/desiredata/extra/makefile
@@ -0,0 +1,96 @@
+current: pd_linux
+
+# ----------------------- NT -----------------------
+
+pd_nt: $(NAME).dll
+
+.SUFFIXES: .dll
+
+PDNTCFLAGS = /W3 /WX /DNT /DPD /nologo
+VC="C:\Program Files\Microsoft Visual Studio\Vc98"
+
+PDNTINCLUDE = /I. /I..\..\src /I$(VC)\include
+
+PDNTLDIR = $(VC)\lib
+PDNTLIB = $(PDNTLDIR)\libc.lib \
+	$(PDNTLDIR)\oldnames.lib \
+	$(PDNTLDIR)\kernel32.lib \
+	..\..\bin\pd.lib 
+
+.c.dll:
+	cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c $*.c
+	link /dll /export:$(CSYM)_setup $*.obj $(PDNTLIB)
+
+# ----------------------- IRIX 5.x -----------------------
+
+pd_irix5: $(NAME).pd_irix5
+
+.SUFFIXES: .pd_irix5
+
+SGICFLAGS5 = -o32 -DPD -DUNIX -DIRIX -O2
+
+SGIINCLUDE =  -I../../src
+
+.c.pd_irix5:
+	$(CC) $(SGICFLAGS5) $(SGIINCLUDE) -o $*.o -c $*.c
+	ld -elf -shared -rdata_shared -o $*.pd_irix5 $*.o
+	rm $*.o
+
+# ----------------------- IRIX 6.x -----------------------
+
+pd_irix6: $(NAME).pd_irix6
+
+.SUFFIXES: .pd_irix6
+
+SGICFLAGS6 = -n32 -DPD -DUNIX -DIRIX -DN32 -woff 1080,1064,1185 \
+	-OPT:roundoff=3 -OPT:IEEE_arithmetic=3 -OPT:cray_ivdep=true \
+	-Ofast=ip32
+
+.c.pd_irix6:
+	$(CC) $(SGICFLAGS6) $(SGIINCLUDE) -o $*.o -c $*.c
+	ld -n32 -IPA -shared -rdata_shared -o $*.pd_irix6 $*.o
+	rm $*.o
+
+# ----------------------- LINUX i386 -----------------------
+
+pd_linux: $(NAME).pd_linux
+
+.SUFFIXES: .pd_linux
+
+LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer -fPIC -m32 \
+    -Wall -W -Wshadow -Wstrict-prototypes \
+    -Wno-unused -Wno-parentheses -Wno-switch $(CFLAGS)
+
+LINUXINCLUDE =  -I../../src
+
+.c.pd_linux:
+	$(CC) $(LINUXCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c
+	$(CC) -m32 -export_dynamic -shared -o $*.pd_linux $*.o -lc -lm
+	strip --strip-unneeded $*.pd_linux
+	rm -f $*.o
+
+# ----------------------- Mac OSX -----------------------
+
+d_ppc: $(NAME).d_ppc
+d_fat: $(NAME).d_fat
+
+.SUFFIXES: .d_ppc .d_fat
+
+DARWINCFLAGS = -DPD -O2 -Wall -W -Wshadow -Wstrict-prototypes \
+    -Wno-unused -Wno-parentheses -Wno-switch
+
+.c.d_ppc:
+	$(CC) $(DARWINCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c
+	$(CC) -bundle -undefined suppress -flat_namespace -o $*.pd_darwin $*.o 
+	rm -f $*.o
+
+.c.d_fat:
+	$(CC) -arch i386 -arch ppc $(DARWINCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c
+	$(CC) -arch i386 -arch ppc -bundle -undefined suppress -flat_namespace \
+	    -o $*.d_fat $*.o 
+	rm -f $*.o
+
+# ----------------------------------------------------------
+
+clean:
+	rm -f *.o *.pd_* so_locations
diff --git a/desiredata/extra/pique/makefile b/desiredata/extra/pique/makefile
new file mode 100644
index 00000000..562ce23b
--- /dev/null
+++ b/desiredata/extra/pique/makefile
@@ -0,0 +1,4 @@
+NAME=pique
+CSYM=pique
+
+include ../makefile
diff --git a/desiredata/extra/pique/pique.c b/desiredata/extra/pique/pique.c
new file mode 100644
index 00000000..f4cae5e1
--- /dev/null
+++ b/desiredata/extra/pique/pique.c
@@ -0,0 +1,238 @@
+/* Copyright (c) 1999 Miller Puckette.  The
+contents of this file are free for any use, but BOTH THE AUTHOR AND UCSD
+DISCLAIM ALL WARRANTIES related to it.  Although not written in Java, this
+still should not be used to control any machinery containing a sharp blade or
+combustible materiel, or as part of any life support system or weapon. */
+
+#include "m_pd.h"
+#include <math.h>
+#include <stdio.h>
+#ifdef NT
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4305 )
+#endif
+
+static t_class *pique_class;
+
+typedef struct _pique
+{
+    t_object x_obj;
+    int x_n;
+    float x_errthresh;
+    float *x_freq;
+    float *x_amp;
+    float *x_ampre;
+    float *x_ampim;
+} t_pique;
+
+static void *pique_new(t_floatarg f)
+{
+    int n = f;
+    t_pique *x = (t_pique *)pd_new(pique_class);
+    if (n < 1) n = 100;
+    x->x_n = n;
+    x->x_errthresh = 0;
+    x->x_freq = t_getbytes(n * sizeof(*x->x_freq));
+    x->x_amp = t_getbytes(n * sizeof(*x->x_amp));
+    x->x_ampre = t_getbytes(n * sizeof(*x->x_ampre));
+    x->x_ampim = t_getbytes(n * sizeof(*x->x_ampim));
+    outlet_new(&x->x_obj, &s_list);
+    return (x);
+}
+
+static float hanning(float pidetune, float sinpidetune)
+{
+    float pi = 3.14159;
+    if (pidetune < 0.01 && pidetune > -0.01) return (1);
+    else if (pidetune > 3.14 && pidetune < 3.143) return (0.5);
+    else if (pidetune < -3.14 && pidetune > -3.143) return (0.5);
+    else return (sinpidetune/pidetune - 0.5 *
+        (sinpidetune/(pidetune+pi) + sinpidetune/(pidetune-pi)));
+}
+
+static float peakerror(float *fpreal, float *fpimag, float pidetune,
+    float norm, float peakreal, float peakimag)
+{
+    float sinpidetune = sin(pidetune);
+    float cospidetune = cos(pidetune);
+    float windowshould = hanning(pidetune, sinpidetune);
+    float realshould = windowshould * (
+        peakreal * cospidetune + peakimag * sinpidetune);
+    float imagshould =  windowshould * (
+        peakimag * cospidetune - peakreal * sinpidetune);
+    float realgot = norm * (fpreal[0] - 0.5 * (fpreal[1] + fpreal[-1]));
+    float imaggot = norm * (fpimag[0] - 0.5 * (fpimag[1] + fpimag[-1]));
+    float realdev = realshould - realgot, imagdev = imagshould - imaggot;
+    
+    /* post("real %f->%f; imag %f->%f", realshould, realgot,
+        imagshould, imaggot); */
+    return (realdev * realdev + imagdev * imagdev);
+}
+
+static void pique_doit(int npts, t_float *fpreal, t_float *fpimag,
+    int npeak, int *nfound, t_float *fpfreq, t_float *fpamp,
+        t_float *fpampre, t_float *fpampim, float errthresh)
+{
+    float srate = sys_getsr();      /* not sure how to get this correctly */
+    float oneovern = 1.0/ (float)npts;
+    float fperbin = srate * oneovern;
+    float pow1, pow2 = 0, pow3 = 0, pow4 = 0, pow5 = 0;
+    float re1, re2 = 0, re3 = *fpreal;
+    float im1, im2 = 0, im3 = 0, powthresh, relativeerror;
+    int count, peakcount = 0, n2 = (npts >> 1);
+    float *fp1, *fp2;
+    for (count = n2, fp1 = fpreal, fp2 = fpimag, powthresh = 0;
+        count--; fp1++, fp2++)
+            powthresh += (*fp1) * (*fp1) + (*fp2) * (*fp2) ; 
+    powthresh *= 0.00001;
+    for (count = 1; count < n2; count++)
+    {
+        float windreal, windimag, pi = 3.14159;
+        float detune, pidetune, sinpidetune, cospidetune,
+            ampcorrect, freqout, ampout, ampoutreal, ampoutimag;
+        float rpeak, rpeaknext, rpeakprev;
+        float ipeak, ipeaknext, ipeakprev;
+        float errleft, errright;
+        fpreal++;
+        fpimag++;
+        re1 = re2;
+        re2 = re3;
+        re3 = *fpreal;
+        im1 = im2;
+        im2 = im3;
+        im3 = *fpimag;
+        if (count < 2) continue;
+        pow1 = pow2;
+        pow2 = pow3;
+        pow3 = pow4;
+        pow4 = pow5;
+            /* get Hanning-windowed spectrum by convolution */
+        windreal = re2 - 0.5 * (re1 + re3);
+        windimag = im2 - 0.5 * (im1 + im3);
+        pow5 = windreal * windreal + windimag * windimag;
+        /* if (count < 30) post("power %f", pow5); */
+        if (count < 5) continue;
+            /* check for a peak.  The actual bin is count-3. */
+        if (pow3 <= pow2 || pow3 <= pow4 || pow3 <= pow1 || pow3 <= pow5
+            || pow3 < powthresh)
+                continue;
+            /* go back for the raw FFT values around the peak. */
+        rpeak = fpreal[-3];
+        rpeaknext = fpreal[-2];
+        rpeakprev = fpreal[-4];
+        ipeak = fpimag[-3];
+        ipeaknext = fpimag[-2];
+        ipeakprev = fpimag[-4];
+            /* recalculate Hanning-windowed spectrum by convolution */
+        windreal = rpeak - 0.5 * (rpeaknext + rpeakprev);
+        windimag = ipeak - 0.5 * (ipeaknext + ipeakprev);
+        
+        detune = ((rpeakprev - rpeaknext) *
+            (2.0 * rpeak - rpeakprev - rpeaknext) +
+                (ipeakprev - ipeaknext) *
+                    (2.0 * ipeak - ipeakprev - ipeaknext)) /
+                        (4.0 * pow3);
+        /* if (count < 30) post("detune %f", detune); */
+        if (detune > 0.7 || detune < -0.7) continue;
+            /* the frequency is the sum of the bin frequency and detuning */ 
+        freqout = fperbin * ((float)(count-3) + detune);
+        pidetune = pi * detune;
+        sinpidetune = sin(pidetune);
+        cospidetune = cos(pidetune);
+        ampcorrect = 1.0 / hanning(pidetune, sinpidetune);
+                /* Multiply by 2 to get real-sinusoid peak amplitude 
+                and divide by N to normalize FFT */
+        ampcorrect *= 2. * oneovern;
+            /* amplitude is peak height, corrected for Hanning window shape */
+
+        ampout = ampcorrect * sqrt(pow3);
+        ampoutreal = ampcorrect *
+            (windreal * cospidetune - windimag * sinpidetune);
+        ampoutimag = ampcorrect *
+            (windreal * sinpidetune + windimag * cospidetune);
+        if (errthresh > 0)
+        {
+            /* post("peak %f %f", freqout, ampout); */
+            errleft = peakerror(fpreal-4, fpimag-4, pidetune+pi,
+                2. * oneovern, ampoutreal, ampoutimag);
+            errright = peakerror(fpreal-2, fpimag-2, pidetune-pi,
+                2. * oneovern,  ampoutreal, ampoutimag);
+            relativeerror = (errleft + errright)/(ampout * ampout);
+            if (relativeerror > errthresh) continue;
+        }
+        /* post("power %f, error %f, relative %f",
+            pow3, errleft + errright, relativeerror); */
+        *fpfreq++ = freqout;
+        *fpamp++ = ampout;
+        *fpampre++ = ampoutreal;
+        *fpampim++ = ampoutimag;
+        if (++peakcount == npeak) break;
+    }
+    *nfound = peakcount;
+}
+
+static void pique_list(t_pique *x, t_symbol *s, int argc, t_atom *argv)
+{
+    int npts = atom_getintarg(0, argc, argv);
+    t_symbol *symreal = atom_getsymbolarg(1, argc, argv);
+    t_symbol *symimag = atom_getsymbolarg(2, argc, argv);
+    int npeak = atom_getintarg(3, argc, argv);
+    int n;
+    t_garray *a;
+    t_float *fpreal, *fpimag;
+    if (npts < 8 || npeak < 1) error("pique: bad npoints or npeak");
+    if (npeak > x->x_n) npeak = x->x_n;
+    if (!(a = (t_garray *)pd_findbyclass(symreal, garray_class)) ||
+        !garray_getfloatarray(a, &n, &fpreal) ||
+            n < npts)
+                error("%s: missing or bad array", symreal->s_name);
+    else if (!(a = (t_garray *)pd_findbyclass(symimag, garray_class)) ||
+        !garray_getfloatarray(a, &n, &fpimag) ||
+            n < npts)
+                error("%s: missing or bad array", symimag->s_name);
+    else
+    {
+        int nfound, i;
+        float *fpfreq = x->x_freq;
+        float *fpamp = x->x_amp;
+        float *fpampre = x->x_ampre;
+        float *fpampim = x->x_ampim;
+        pique_doit(npts, fpreal, fpimag, npeak,
+            &nfound, fpfreq, fpamp, fpampre, fpampim, x->x_errthresh);
+        for (i = 0; i < nfound; i++, fpamp++, fpfreq++, fpampre++, fpampim++)
+        {
+            t_atom at[5];
+            SETFLOAT(at, (float)i);
+            SETFLOAT(at+1, *fpfreq);
+            SETFLOAT(at+2, *fpamp);
+            SETFLOAT(at+3, *fpampre);
+            SETFLOAT(at+4, *fpampim);
+            outlet_list(x->x_obj.ob_outlet, &s_list, 5, at);   
+        }
+    }
+}
+
+static void pique_errthresh(t_pique *x, t_floatarg f)
+{
+    x->x_errthresh = f;
+}
+
+static void pique_free(t_pique *x)
+{
+    int n = x->x_n;
+    t_freebytes(x->x_freq, n * sizeof(*x->x_freq));
+    t_freebytes(x->x_amp, n * sizeof(*x->x_amp));
+    t_freebytes(x->x_ampre, n * sizeof(*x->x_ampre));
+    t_freebytes(x->x_ampim, n * sizeof(*x->x_ampim));
+}
+
+void pique_setup(void)
+{
+    pique_class = class_new(gensym("pique"), (t_newmethod)pique_new,
+        (t_method)pique_free, sizeof(t_pique),0, A_DEFFLOAT, 0);
+    class_addlist(pique_class, pique_list);
+    class_addmethod(pique_class, (t_method)pique_errthresh,
+        gensym("errthresh"), A_FLOAT, 0);
+    post("pique 0.1 for PD version 23");
+}
+
diff --git a/desiredata/extra/pique/pique.c.old b/desiredata/extra/pique/pique.c.old
new file mode 100644
index 00000000..75afc38c
--- /dev/null
+++ b/desiredata/extra/pique/pique.c.old
@@ -0,0 +1,148 @@
+/* Copyright (c) 1998 The Regents of the University of California.  The
+contents of this file are free for any use, but BOTH THE AUTHOR AND UCSD
+DISCLAIM ALL WARRANTIES related to it.  Although not written in Java, this
+still should not be used to control any machinery containing a sharp blade or
+combustible materiel, or as part of any life support system or weapon. */
+
+#include "m_pd.h"
+#include <math.h>
+
+static t_class *pique_class;
+
+typedef struct _pique
+{
+    t_object x_obj;
+} t_pique;
+
+static void *pique_new(void)
+{
+    t_pique *x = (t_pique *)pd_new(pique_class);
+    return (x);
+}
+
+    	    /* we aren't measuring phase yet */
+static void pique_doit(int npts, t_float *fpreal, t_float *fpimag,
+    int npeak, t_float *fpfreq, t_float *fpamp)
+{
+    float srate = sys_getsr();	    /* not sure how to get this correctly */
+    float oneovern = 1.0/ (float)npts;
+    float fperbin = srate * oneovern;
+    float pow1, pow2 = 0, pow3 = 0, pow4 = 0, pow5 = 0;
+    float re1, re2 = 0, re3 = *fpreal;
+    float im1, im2 = 0, im3 = 0, powthresh;
+    int count, peakcount = 0, n2 = (npts >> 1);
+    float *fp1, *fp2;
+    for (count = n2, fp1 = fpreal, fp2 = fpimag, powthresh = 0;
+    	count--; fp1++, fp2++)
+    	    powthresh += (*fp1) * (*fp1) + (*fp2) * (*fp2) ; 
+    powthresh *= 0.00001;
+    for (count = 1; count < n2; count++)
+    {
+    	float windreal, windimag, pi = 3.14159;
+    	float detune, pidetune, ampcorrect, freqout, ampout;
+    	float rpeak, rpeaknext, rpeakprev;
+    	float ipeak, ipeaknext, ipeakprev;
+    	fpreal++;
+    	fpimag++;
+    	re1 = re2;
+    	re2 = re3;
+    	re3 = *fpreal;
+    	im1 = im2;
+    	im2 = im3;
+    	im3 = *fpimag;
+    	if (count < 2) continue;
+    	pow1 = pow2;
+    	pow2 = pow3;
+    	pow3 = pow4;
+    	pow4 = pow5;
+    	    /* get Hanning-windowed spectrum by convolution */
+    	windreal = re2 - 0.5 * (re1 + re3);
+    	windimag = im2 - 0.5 * (im1 + im3);
+    	pow5 = windreal * windreal + windimag * windimag;
+    	/* if (count < 30) post("power %f", pow5); */
+    	if (count < 5) continue;
+    	    /* check for a peak.  The actual bin is count-3. */
+    	if (pow3 <= pow2 || pow3 <= pow4 || pow3 <= pow1 || pow3 <= pow5
+    	    || pow3 < powthresh)
+    	    	continue;
+    	    /* go back for the raw FFT values around the peak. */
+    	rpeak = fpreal[-3];
+    	rpeaknext = fpreal[-2];
+    	rpeakprev = fpreal[-4];
+    	ipeak = fpimag[-3];
+    	ipeaknext = fpimag[-2];
+    	ipeakprev = fpimag[-4];
+    	
+    	detune = ((rpeakprev - rpeaknext) *
+    	    (2.0 * rpeak - rpeakprev - rpeaknext) +
+    	    	(ipeakprev - ipeaknext) *
+    	    	    (2.0 * ipeak - ipeakprev - ipeaknext)) /
+    	    	    	(4.0 * pow3);
+    	/* if (count < 30) post("detune %f", detune); */
+    	if (detune > 0.7 || detune < -0.7) continue;
+    	    /* the frequency is the sum of the bin frequency and detuning */ 
+    	freqout = fperbin * ((float)(count-3) + detune);
+    	*fpfreq++ = freqout;
+    	pidetune = pi * detune;
+    	if (pidetune < 0.01 && pidetune > -0.01) ampcorrect = 1;
+    	else ampcorrect = 1.0 / (sin(pidetune)/pidetune + 0.5 *
+    	    (sin(pidetune + pi)/(pidetune+pi) +
+    	    	sin(pidetune-pi)/(pidetune-pi)));
+    	    /* amplitude is peak height, corrected for Hanning window shape.
+    	    	Multiply by 2 to get real-sinusoid peak amplitude  */
+    	ampout = 2. * oneovern * sqrt(pow3) * ampcorrect;
+    	*fpamp++ = ampout;
+    	/* post("peak %f %f", freqout, ampout); */
+    	if (++peakcount == npeak) break;
+    }
+    while (peakcount < npeak)
+    {
+    	*fpfreq++ = 0;
+    	*fpamp++ = 0;
+    	peakcount++;
+    }
+}
+
+static void pique_list(t_pique *x, t_symbol *s, int argc, t_atom *argv)
+{
+    int npts = atom_getintarg(0, argc, argv);
+    t_symbol *symreal = atom_getsymbolarg(1, argc, argv);
+    t_symbol *symimag = atom_getsymbolarg(2, argc, argv);
+    int npeak = atom_getintarg(3, argc, argv);
+    t_symbol *symfreq = atom_getsymbolarg(4, argc, argv);
+    t_symbol *symamp = atom_getsymbolarg(5, argc, argv);
+    t_garray *a, *afreq, *aamp;
+    int n;
+    t_float *fpreal, *fpimag, *fpfreq, *fpamp, *fpphase;
+    if (npts < 8 || npeak < 1) error("pique: bad npoints or npeak");
+    else if (!(a = (t_garray *)pd_findbyclass(symreal, garray_class)) ||
+    	!garray_getfloatarray(a, &n, &fpreal) ||
+    	    n < npts)
+    	    	error("%s: missing or bad array", symreal->s_name);
+    else if (!(a = (t_garray *)pd_findbyclass(symimag, garray_class)) ||
+    	!garray_getfloatarray(a, &n, &fpimag) ||
+    	    n < npts)
+    	    	error("%s: missing or bad array", symimag->s_name);
+    else if (!(afreq = (t_garray *)pd_findbyclass(symfreq, garray_class)) ||
+    	!garray_getfloatarray(afreq, &n, &fpfreq) ||
+    	    n < npeak)
+    	    	error("%s: missing or bad array", symfreq->s_name);
+    else if (!(aamp = (t_garray *)pd_findbyclass(symamp, garray_class)) ||
+    	!garray_getfloatarray(aamp, &n, &fpamp) ||
+    	    n < npeak)
+    	    	error("%s: missing or bad array", symamp->s_name);
+    else
+    {
+    	pique_doit(npts, fpreal, fpimag, npeak, fpfreq, fpamp);
+    	garray_redraw(afreq);
+    	garray_redraw(aamp);
+    }
+}
+
+void pique_setup(void)
+{
+    pique_class = class_new(gensym("pique"), pique_new, 0,
+    	sizeof(t_pique), 0, 0);
+    class_addlist(pique_class, pique_list);
+}
+
diff --git a/desiredata/extra/pureunity/2times.pd b/desiredata/extra/pureunity/2times.pd
new file mode 100644
index 00000000..5f3eeecd
--- /dev/null
+++ b/desiredata/extra/pureunity/2times.pd
@@ -0,0 +1,31 @@
+#N canvas 330 193 379 266 10;
+#X obj 20 16 inlet;
+#X obj 69 108 inlet;
+#X obj 108 108 inlet;
+#X obj 85 54 t a a;
+#X obj 20 35 route bang;
+#X obj 20 54 t b b;
+#X obj 118 211 pack s s;
+#X obj 46 209 pack 0 0;
+#X obj 46 241 outlet;
+#X obj 46 130 \$1 \$2;
+#X obj 85 130 \$1 \$3;
+#X obj 85 170 route float;
+#X obj 46 190 route float;
+#X connect 0 0 4 0;
+#X connect 1 0 9 1;
+#X connect 2 0 10 1;
+#X connect 3 0 9 0;
+#X connect 3 1 10 0;
+#X connect 4 0 5 0;
+#X connect 4 1 3 0;
+#X connect 5 0 9 0;
+#X connect 5 1 10 0;
+#X connect 6 0 8 0;
+#X connect 7 0 8 0;
+#X connect 9 0 12 0;
+#X connect 10 0 11 0;
+#X connect 11 0 7 1;
+#X connect 11 1 6 1;
+#X connect 12 0 7 0;
+#X connect 12 1 6 0;
diff --git a/desiredata/extra/pureunity/3times.pd b/desiredata/extra/pureunity/3times.pd
new file mode 100644
index 00000000..706d41db
--- /dev/null
+++ b/desiredata/extra/pureunity/3times.pd
@@ -0,0 +1,40 @@
+#N canvas 330 193 379 266 10;
+#X obj 20 16 inlet;
+#X obj 69 108 inlet;
+#X obj 108 108 inlet;
+#X obj 20 35 route bang;
+#X obj 46 241 outlet;
+#X obj 46 130 \$1 \$2;
+#X obj 85 130 \$1 \$3;
+#X obj 85 170 route float;
+#X obj 46 190 route float;
+#X obj 20 54 t b b b;
+#X obj 147 108 inlet;
+#X obj 124 130 \$1 \$4;
+#X obj 124 150 route float;
+#X obj 118 211 pack s s s;
+#X obj 46 209 pack 0 0 0;
+#X obj 85 54 t a a a;
+#X connect 0 0 3 0;
+#X connect 1 0 5 1;
+#X connect 2 0 6 1;
+#X connect 3 0 9 0;
+#X connect 3 1 15 0;
+#X connect 5 0 8 0;
+#X connect 6 0 7 0;
+#X connect 7 0 14 1;
+#X connect 7 1 13 1;
+#X connect 8 0 14 0;
+#X connect 8 1 13 0;
+#X connect 9 0 5 0;
+#X connect 9 1 6 0;
+#X connect 9 2 11 0;
+#X connect 10 0 11 1;
+#X connect 11 0 12 0;
+#X connect 12 0 14 2;
+#X connect 12 1 13 2;
+#X connect 13 0 4 0;
+#X connect 14 0 4 0;
+#X connect 15 0 5 0;
+#X connect 15 1 6 0;
+#X connect 15 2 11 0;
diff --git a/desiredata/extra/pureunity/4times.pd b/desiredata/extra/pureunity/4times.pd
new file mode 100644
index 00000000..ed5f3f41
--- /dev/null
+++ b/desiredata/extra/pureunity/4times.pd
@@ -0,0 +1,49 @@
+#N canvas 330 193 381 323 10;
+#X obj 20 16 inlet;
+#X obj 69 108 inlet;
+#X obj 108 108 inlet;
+#X obj 20 35 route bang;
+#X obj 46 261 outlet;
+#X obj 46 130 \$1 \$2;
+#X obj 85 130 \$1 \$3;
+#X obj 85 190 route float;
+#X obj 46 210 route float;
+#X obj 147 108 inlet;
+#X obj 124 130 \$1 \$4;
+#X obj 124 170 route float;
+#X obj 20 54 t b b b b;
+#X obj 85 54 t a a a a;
+#X obj 187 108 inlet;
+#X obj 164 130 \$1 \$5;
+#X obj 134 229 pack s s s s;
+#X obj 46 229 pack 0 0 0 0;
+#X obj 164 150 route float;
+#X connect 0 0 3 0;
+#X connect 1 0 5 1;
+#X connect 2 0 6 1;
+#X connect 3 0 12 0;
+#X connect 3 1 13 0;
+#X connect 5 0 8 0;
+#X connect 6 0 7 0;
+#X connect 7 0 17 1;
+#X connect 7 1 16 1;
+#X connect 8 0 17 0;
+#X connect 8 1 16 0;
+#X connect 9 0 10 1;
+#X connect 10 0 11 0;
+#X connect 11 0 17 2;
+#X connect 11 1 16 2;
+#X connect 12 0 5 0;
+#X connect 12 1 6 0;
+#X connect 12 2 10 0;
+#X connect 12 3 15 0;
+#X connect 13 0 5 0;
+#X connect 13 1 6 0;
+#X connect 13 2 10 0;
+#X connect 13 3 15 0;
+#X connect 14 0 15 1;
+#X connect 15 0 18 0;
+#X connect 16 0 4 0;
+#X connect 17 0 4 0;
+#X connect 18 0 17 3;
+#X connect 18 1 16 3;
diff --git a/desiredata/extra/pureunity/COPYING b/desiredata/extra/pureunity/COPYING
new file mode 100644
index 00000000..eeb586b3
--- /dev/null
+++ b/desiredata/extra/pureunity/COPYING
@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) 19yy name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/desiredata/extra/pureunity/ChangeLog b/desiredata/extra/pureunity/ChangeLog
new file mode 100644
index 00000000..3f7bfd54
--- /dev/null
+++ b/desiredata/extra/pureunity/ChangeLog
@@ -0,0 +1,23 @@
+$Id: ChangeLog,v 1.1.2.2 2007-01-05 02:21:13 matju Exp $
+
+version 0.40.pre6 (2007.01.04):
+ * requires 0.40
+ * goes into DesireData pre6
+ * swap the order in the name of class templates
+
+
+version 0.0 (2006.01.06):
+ * LICENSE is GPL
+ * doc is in README
+ * new object classes:
+   * [commutator],   [commutative-test]
+   * [associator],   [associative-test]
+   * [invertor],      [invertible-test]
+   * [distributor], [distributive-test]
+   * [trichotomy-test], ...
+   * [twice], [3times], [4times], [^]
+   * [tree], [protocols-tree]
+   * [rtimer]
+   * for $1 in f,~ and some of #:
+     [$1.norm], [$1.taa], [$1.do], [$1.packunpack3], [$1.swap]
+     [$1.inlet], [$1.outlet]
diff --git a/desiredata/extra/pureunity/Makefile b/desiredata/extra/pureunity/Makefile
new file mode 100644
index 00000000..a9e9ec88
--- /dev/null
+++ b/desiredata/extra/pureunity/Makefile
@@ -0,0 +1,19 @@
+# if you don't want the standard pd, set the PD-variable before doing "make"
+# e.g. "PD=/home/matju/pd_devel_0_39_und/bin/pd make"
+ PD ?= pd
+#PD ?= desire
+PDFLAGS = -lib pureunity -noaudio
+PDFLAGS += -lib gridflow
+CFLAGS = -Wall
+
+test:: built
+	$(PD) $(PDFLAGS) main.pd
+
+built: Makefile pureunity.pd_linux
+	echo > built
+
+generic/%~.pd: generic/%.pd
+
+pureunity.pd_linux: pureunity.c Makefile
+	$(CC) $(CFLAGS) -shared -o pureunity.pd_linux pureunity.c
+
diff --git a/desiredata/extra/pureunity/README b/desiredata/extra/pureunity/README
new file mode 100644
index 00000000..a3990537
--- /dev/null
+++ b/desiredata/extra/pureunity/README
@@ -0,0 +1,624 @@
+$Id: README,v 1.1.2.2 2007-06-01 16:31:54 matju Exp $
+
+PureUnity
+
+Copyright 2006 by Mathieu Bouchard <matju à artengine point ca>
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+See file ./COPYING for further informations on licensing terms.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
++-+-+--+---+-----+--------+-------------+---------------------+
+GOALS
+
+  1. To provide a unit-test framework, which also provide benchmarking
+     features, all made in Pd for use in Pd.
+
+  2. To provide tests for functionality in internals, externals, abstractions, 
+     etc., in a modularized way, in a DRY/OAOO fashion, thus abstracting out
+     common features so that many objects share the same test patch for the 
+     features that they have in common.
+
++-+-+--+---+-----+--------+-------------+---------------------+
+REQUIREMENTS
+
+  1. Pd 0.39 (PureMSP or Devel)
+
++-+-+--+---+-----+--------+-------------+---------------------+
+TEST PROTOCOL
+
+  new:
+    create common (reusable) fixtures.
+
+  inlet 0:
+    bang:
+      run all available tests in that class. individual tests don't have
+      to be available through individual methods but may. If they do, the
+      names of the methods must match those given in the test results. 
+
+      each test should build its own non-reusable fixtures and reinitialize
+      common fixtures, not assuming that the previous tests have left the
+      common fixtures in a normal state.
+
+  outlet 0:
+    test results. a sequence of lists like:
+      list $passed? $accuracy $elapsed $name1 ...
+
+    where:
+      $passed? is either 0 for failure or 1 for success
+      $accuracy is a float proportional to relative error on math
+         (if not applicable, use 0)
+      $elapsed is a nonnegative float, the time elapsed in milliseconds
+         or it is any negative float meaning the time hasn't been measured.
+      $name1 and the rest are symbols and/or floats identifying the test
+
+    for example:
+      list 1 0 -1 commutative f + *
+
+    Which means that the 1st test about commutativity passed ($2=1) because it
+    was perfectly accurate ($3==0) and that we didn't measure the time ($4=-).
+
++-+-+--+---+-----+--------+-------------+---------------------+
+SEVERITIES (in decreasing order)
+
+ * crash: Segmentation Fault, Bus Error, Illegal Instruction, Infinite Loop,
+   etc.  You can't deal with those errors at the level of the tests. Maybe there 
+   should be a way to tell a test object to skip certain tests, by name, in 
+   order to be able to perform as many tests as possible while waiting for a 
+   fix. It could become possible to rescue from some of those crashes if Pd
+   supported exceptions (stack-unwinding).
+
+ * corruption: this may cause future crashes and failures on innocent 
+   objects/features. I have no solution for this except to be careful.
+
+ * post(),error(),pd_error(): Gets printed in the console. The problem is that 
+   those can't be handled by the test objects, so someone has to read them and 
+   interpret them. Also they prevent test objects to ensure that error 
+   conditions produce error messages. This includes stack overflow.
+
+ * pd_error2(): I wish this would exist. It would be sort of like pd_error() 
+   but it would produce a pd message instead, whose selector would be an 
+   error code, designed to be both localizable and [route]able. By default, that 
+   message would be sent to the console, but there would be an internal class
+   designed to catch those messages. (If stack-unwinding were possible, it would 
+   be disabled by default on pd_error2 and could be enabled explicitly 
+   by-selector).
+
+ * failure: a test object reports a problem through outlet 0.
+
+ * dropout: a failure in realtimeness... difficult for an object to detect.
+
+ * inaccuracy: a test more or less succeeds but the test detected that the 
+   epsilon sucks.
+
++-+-+--+---+-----+--------+-------------+---------------------+
+PROTOCOL FOR [error]
+
+new:
+  optional argument which would either be a float
+  (e.g. the $0 of the enclosing abstraction) or a pointer.
+
+inlet 0:
+  set $scapegoat:
+    replaces the originator of the message by $scapegoat, which can be a
+    float or a pointer
+
+  error $1 ...:
+    causes its arguments to be concatenated, space-separated (may include
+    floats), and then sent through pd_error using the appropriate
+    originator (scapegoat).
+
+  list $1 ...:
+    for future use. would use pd_error2() (see README or previous mail).
+    $1 has to be a symbol.
+
++-+-+--+---+-----+--------+-------------+---------------------+
+ACCURACY AND ERROR (in math-related unit tests)
+
+The "absolute error" between a practical result and the expected value
+is considered to be the distance between the two value. That is the
+absolute value of the difference.
+
+In the case of positions in 2D, 3D, etc., use the L2-Norm which is
+a generalized Pythagoras' Theorem: dist^2 = x^2 + y^2 + z^2 + ...
+A norm is a distance between something and zero.
+
+Sometimes you have several practical results for one expected value
+and must extract a single absolute error out of that. Then you should pick
+the largest of the individual absolute errors.
+
+Sometimes you don't have an expected value, you just have several
+practical results that you expect to be quite the same. In that case,
+the absolute error is the "diameter" of those results. The meaning
+of diameter here is: the largest distance between any two results.
+
+If in a single test you must compare 2D errors with 3D errors and 1D
+errors, etc., you may have to adjust them by dividing the error by
+the square root of N (N is the number of dimensions). In that case,
+the resulting value is called a RMS (Root-Mean-Square).
+
+The maximum error introduced by just representing a number as a float
+(instead of an exact value) is at most proportional to the magnitude
+of the number (e.g. usually 16 million times smaller: about 6 decimals).
+Also, often we are only interested in relative error, which is absolute
+error divided by the norm of the expected result, because small absolute
+errors don't matter much with large results. This is the reason floats
+exist in the first place. By default, use relative error as the $accuracy
+in Pd tests.
+
+If you don't have an expected result, then compute the relative error as
+being the absolute error divided by the norm of the average of practical
+results.
+
+In the RMS case of relative error, the norms of expected results should also
+be adjusted, but both adjustments cancel because they get divided by each
+other. That means: don't divide by the sqrt(N) at all and you'll get an
+appropriate result.
+
++-+-+--+---+-----+--------+-------------+---------------------+
+TYPE PREFIXES
+
+Those have to be prefixes in order to be honored by DOLLSYM:
+[$1norm] should expand to [fnorm], [lfnorm], [#norm], etc.
+
+Those prefixes are necessary in order to achieve polymorphism through
+abstraction arguments.
+
+CURRENT:
+  f   float
+  ~   signal
+
+FUTURE (from PureData):
+  s   symbol
+  p   gpointer
+  a   anything
+  l   list (of whatever)
+  lf  list of floats
+  ls  list of symbols
+  lp  list of pointers
+
+FUTURE (from DesireData):
+  L   listpointer (still trying to figure out whether this will really happen)
+  v   varpointer (instance symbol)
+
+FUTURE (from GridFlow):
+  #   grid (of whatever)
+  #b  grid of bytes (uint8)
+  #s  grid of shorts (int16)
+  #i  grid of ints (int32)
+  #l  grid of longs (int64)
+  #f  grid of floats (float32)
+  #d  grid of doubles (float64)
+  #t  grid of Tcl_Object or t_atom or I don't know what.
+
+for a type prefix to be considered implemented, it has to
+have the following class set:
+
+  metaabstraction   for floats   for signals   for grids
+  [inlet.$1]         [inlet]      [inlet~]      [inlet]
+  [outlet.$1]       [outlet]     [outlet~]     [outlet]
+  [op2.$1 $2 $3]    [$2 $3]      [$2~ $3]      [# $2 $3]
+  [taa.$1]          [t a a]      noop          [t a a]
+  [swap.$1]         [swap]       noop          TODO
+  [norm.$1]         [abs]        [env~]        [# sq]->[#ravel]->[#fold +]->[#export]->[sqrt]
+  [packunpack3.$1]  pack,unpack  noop          TODO
+  [rand.$1]         ..................................
+
+The first two cannot be implemented as abstractions and instead must be
+defined as aliases in pureunity.c.
+
+extra metaabstractions:
+  [$1.rand]         [f.rand]     [~.rand]TODO  [#.rand]TODO
+
++-+-+--+---+-----+--------+-------------+---------------------+
+OTHER PROTOCOLS
+
+Those four classes are operators that give verify algebraic properties
+of other operators. The more their outputs are close to zero, the more
+those other operators are faithful to an algebraic property.
+
+(here, supported $types are f and ~)
+
+[commutator  $type $class]          (2 inlets)     ab-ba
+[associator  $type $class]          (2 inlets)  (ab)c-a(bc)
+[distributor $type $class1 $class2] (3 inlets) a&(b^c)-(a&b^a&c)
+[invertor    $type $class1 $class2] (2 inlets)   ab/b-a
+
++-+-+--+---+-----+--------+-------------+---------------------+
+TESTS AND RULES
+
+For each class, a test file's name is the class name followed by "-test.pd",
+and a rule file's name is the class name followed by "-rule.pd",
+in the same way as it is for help files.
+
+for a class called $foo, the protocol (aka interface aka rule) $foo is the
+set of behaviours expected from the $foo class; the class called $foo-rule
+must repect the $foo protocol as well, plus it should test that the inputs
+are valid, and if they are, it should test for one or several results and
+report any errors.
+
+To report errors and inaccuracies, output them through the properties outlet
+at the right. If there is no properties outlet in $foo (curently almost
+nothing in Pd has one), then $foo-rule must have one more outlet than $foo.
+
+Float messages coming out of the properties outlet of $foo-rule report
+accuracy. Named error messages come out with selector "error" followed by
+an error-symbol and then its arguments.
+
+In the case of true/false logic, a value of 0 means that a test has passed
+and a 1 means that a test has failed. Those values represent failure and not
+success. The reason is so that it matches with accuracy levels, where 0 is
+perfectly accurate, but any inaccuracy shows up as a relative error fraction.
+Any finite nonnegative value is allowed for accuracy, because it is expected
+to be the result of a norm.
+
+In standard math, "Discrete Metric" is when there are only two possible
+distances between objects: together=0 and apart=1
+
++-+-+--+---+-----+--------+-------------+---------------------+
+RANDOMIZERS (?)
+
++-+-+--+---+-----+--------+-------------+---------------------+
+ETC
+
+(write me!)
+
+If +-test.pd tests [+], it can test for hotness, coldness, it can test
+that only one result is produced per hot message, that all results are
+float, that a few example additions work, and that with random inputs it
+respects commutativity, associativity, invertibility, within appropriate
+relative-error bounds, etc.
+
+However +-test.pd can't test that errormessages aren't printed during the
+testing. This may be something that we want to check for, and currently
+the best way to handle it is to search the console for error messages, and
+if there are any, restart the tests in verbose mode and see where the
+error happens exactly.
+
+[...]
+
+Floating-point is the scientific notation for numbers that we all
+learned on paper in school. Rounding and inaccuracy are two sides
+of the same coin. They are required when it is stupid to have perfect
+results, that is, when it would mean too many computations for little
+gain.
+
+However sometimes we want to make sure that our math is accurate enough.
+Many algorithms are data-recursive: each computation uses previous
+results. Many of those algorithms have chaotic and/or unstable
+behaviours, which means that the inaccuracies may skyrocket instead of
+fading out.
+
++-+-+--+---+-----+--------+-------------+---------------------+
+
+Date: Fri, 13 Jan 2006 04:07:59 +0900
+From: Mathieu Bouchard <matju@artengine.ca>
+Reply-To: ruby-core@ruby-lang.org
+To: ruby-core@ruby-lang.org
+Subject: Re: Design contracts and refactoring (was Re: mathn: ugly warnings)
+
+On Fri, 13 Jan 2006, mathew wrote:
+
+> *Dean Wampler *<deanwampler gmail.com> writes:
+> > Let me suggest an XP-style alternative; make thorough unit tests
+> > required and make sure they "document" - and test! - the design
+> > "contract".
+> Unit tests are not an alternative. They are an additional requirement.
+
+I find unit-tests to be often decomposable like this. Start with something
+like this:
+
+  raise if Blah.new(666) != Blah.new(666)
+  raise if Blah.new(747) != Blah.new(747)
+  raise if Blah.new(242) != Blah.new(242)
+  raise if Blah.new(69)  != Blah.new(69)
+  raise if Blah.new(37)  != Blah.new(37)
+
+then generalize it ("equality is defined based on the arg of .new"):
+
+  for x in [666,747,242,69,37] do
+    raise if Blah.new(x) != Blah.new(x)
+  end
+
+then extract a contract from it:
+
+  class CheckedBlah < Blah
+    def self.new(x)
+      r = super(x)
+      raise if r != super(x)
+      r
+    end
+  end
+
+so now all Blah object creation may be checked throughout actual uses of a
+program and not just unit tests. The unit test now reduces to:
+
+  for x in [666,747,242,69,37] do Blah.new(x) end
+
+so for many unit tests, all you have to do is just do things and discard
+the results, and the contract will do the job of checking.
+
+ _ _ __ ___ _____ ________ _____________ _____________________ ...
+| Mathieu Bouchard - tél:+1.514.383.3801 - http://artengine.ca/matju
+| Freelance Digital Arts Engineer, Montréal QC Canada
+
++-+-+--+---+-----+--------+-------------+---------------------+
+
+Date: Fri, 13 Jan 2006 05:05:19 +0900
+From: Mathieu Bouchard <matju@artengine.ca>
+Reply-To: ruby-core@ruby-lang.org
+To: ruby-core@ruby-lang.org
+Subject: Re: Design contracts and refactoring (was Re: mathn: ugly warnings)
+
+On Fri, 13 Jan 2006, mathew wrote:
+
+> For example, consider a simple vector addition routine in a 3D library.
+> The unit tests might test its behavior with Float and Integer vectors,
+> since that's why it was written.
+
+Here's another way to factor unit-tests that I haven't mentioned in the
+last mail.
+
+suppose you test for + using:
+
+  class IntegerTest
+    def test; 2+2==4 or raise; end
+  end
+  class FloatTest
+    def test; 2.0+2.0==4.0 or raise; end
+  end
+  class RationalTest
+    def test; Rational(2,1)+Rational(2,1)==Rational(4,1) or raise; end
+  end
+
+you can refactor those tests like this:
+
+  class NumericTest
+    def initialize nt; @nt; end
+    def make x; raise "abstract class" end
+    def test; make(2)+make(2)==make(4) or raise; end
+  end
+  class  IntegerTest; def make x;  Integer(x)   end end
+  class    FloatTest; def make x;    Float(x)   end end
+  class RationalTest; def make x; Rational(x,1) end end
+
+> However, to do that you need to know whether the feature of supporting
+> (say) Complex vectors or BigDecimal vectors is intended or not. The unit
+> tests won't tell you this.
+
+[...]
+
+> > One limitation of documentation is that it has no enforcement power,
+> > so you have to write tests anyway to test conformance.
+> Unit tests have no enforcement power either, because you can just change the
+> test. Indeed, I've already had to do this once when it turned out that the
+> unit test was wrong. (In net/ftp.)
+
+That was a pretty bad case of strawman argument. Dean was assuming that
+your documentation was not executable when you had quite clearly stated
+that it was the contracts that acted as documentation!
+
+[...]
+
++-+-+--+---+-----+--------+-------------+---------------------+
+
+Date: Fri, 13 Jan 2006 07:36:36 +0900
+From: Mathieu Bouchard <matju@artengine.ca>
+Reply-To: ruby-core@ruby-lang.org
+To: ruby-core@ruby-lang.org
+Subject: Re: Design contracts and refactoring (was Re: mathn: ugly warnings)
+
+On Fri, 13 Jan 2006, mathew wrote:
+
+> >  The XP view is
+> > that you should eliminate the redundancy.
+> Except it's not redundancy.
+> Unit tests define a set of functionality that is required. Documentation tells
+> you the functionality that is supported, which is generally a superset of the
+> functionality required by the unit tests.
+
+Let's follow the argument of both of you to the end.
+
+1. Unit-tests often match inputs with outputs on a case-by-case basis.
+
+2. Redundancy should be eliminated.
+
+(1) suggests that there is a shorter way to express the unit-tests.
+Suppose you are able to find a formula for generating output-validators
+from inputs. Then that formula is a postcondition of a contract, and the
+explicit output-validators of the unit-tests are redundant.
+
+(2) because part of the unit-tests are redundant, part of the unit-tests
+should be eliminated. This causes the postconditions to become an
+essential part of unit-testing.
+
+Unit-tests vs contracts is a false debate.
+
+ _ _ __ ___ _____ ________ _____________ _____________________ ...
+| Mathieu Bouchard - tél:+1.514.383.3801 - http://artengine.ca/matju
+| Freelance Digital Arts Engineer, Montréal QC Canada
+
+
++-+-+--+---+-----+--------+-------------+---------------------+
+Date: Fri, 13 Jan 2006 17:19:41 +0900
+From: Mathieu Bouchard <matju@artengine.ca>
+Reply-To: ruby-core@ruby-lang.org
+To: ruby-core@ruby-lang.org
+Subject: Re: Design contracts and refactoring (was Re: mathn: ugly warnings)
+
+[...]
+
+In order to entrench the tests-as-documentation habit firmly in the Ruby
+community, we need a catchy acronym. Like RTFUT = Read the Fabulous Unit
+Tests!
+
++-+-+--+---+-----+--------+-------------+---------------------+
+http://lists.puredata.info/pipermail/pd-dev/2006-01/005920.html
+Date: Fri, 20 Jan 2006 23:52:22 -0500 (EST)
+From: Mathieu Bouchard <matju@artengine.ca>
+To: pd-dev <pd-dev@iem.at>
+Subject: macros and such (was: pd-lib, SIMD)
+
+[...]
+
+I think that the Pd source doesn't use nearly enough macros or other
+code-reducing tricks.
+
+The reduction of code isn't so much about making things use less RAM: the
+RAM excuse is quickly evaporating as even the tiniest computers come with
+plenty of RAM and even the faster kinds of RAM come in ever more copious
+amounts (big caches).
+
+The reduction of code is programmer-oriented. I'm not talking about length
+of identifiers here (this is a separate issue). Every line of code should
+do something interesting by itself. Code should read like a good story and
+not like a car. Ever tried to read a car? It's boring. The same damn
+piston copy-pasted 12 times.
+
+The reduction of code is also documentation-oriented. Once the programmer
+has been contaminated with the wisdom required to make small code or
+understand small code, then why wouldn't the programmer explain it to his
+students in higher-level terms instead of chanting 12 times the same
+piston as if it were a marathon of Hail-Marys ?
+
+This is why Pd needs a taxonomy of object classes. If I don't get that
+taxonomy in Pd itself nor in its help files, at least I'll have it in its
+unit tests.
+
+Once and only once.
+Once and only once.
+Once and only once.
+Three strikes and you refactor.
+for x in [1,2,3] say: Once and only once
+
+http://c2.com/cgi/wiki/?ThreeStrikesAndYouRefactor
+
+BTW I'm not talking about only inheritance of implementations. The most
+important thing to me is inheritance of expectations, so that if I name
+100 classes that obey the rule "Operator2", then you have just learned
+something common about 100 classes.
+
+Operator2 means right-inlet is cold, left-inlet is hot, there is a "set"
+method for using left-inlet as cold, there is a "bang" for explicitly
+activating the main computation. The main computation only produces one
+message. That's what "Operator2" means in my taxonomy, and it's that much
+that hasn't to be stated explicitly in each help patch.
+
+Help patches can be abstractions to be used to by other help patches. Just
+put a [operator2-help] object in your help patch to indicate that the
+currently documented class obeys the standard operator2 rules.
+
+Who's against it?
+
++-+-+--+---+-----+--------+-------------+---------------------+
+http://lists.puredata.info/pipermail/pd-list/2006-02/035169.html
+Date: Sat Feb 4 21:22:29 CET 2006
+From: Mathieu Bouchard <matju@artengine.ca>
+To: pd-list
+
+    * Previous message: [PD] dealing with arguments and inlets
+    * Next message: [PD] Re: [PD-announce] A new version of FFTease is now available for Pd
+    * Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
+
+On Fri, 3 Feb 2006, Hans-Christoph Steiner wrote:
+
+> The way I have been thinking is that the first inlet is the general
+> inlet, and it can accept many types of messages.  Then the second inlet
+> lines up with the first argument, the third inlet to the second
+> argument, etc.
+
+I agree. Many objects obey the rule that the k'th inlet matches argument
+$k for several arguments in a row, usually all of them.
+
+>  I think this is pretty clean and flexible, and I think
+> it would be nice to have some kind of standard for this.
+
+And the best way to make sure people are following a standard is to make 
+it so easy to follow that it's harder to not follow it than to follow it. 
+Of course I don't mean adding hurdles to doing it otherwise, but rather 
+make a shortcut for those who follow the standard. Short of this, people 
+who make abstractions/externals can get a friendly reminder, from someone 
+who cares, that it would be better if they followed the standard.
+
+> Obviously, it doesn't work for all objects, but I think it would be good to
+> standardize on objects it does work for.
+
+PureUnity's goal (when I work on it) is to design a taxonomy that 
+separates objects that obey certain properties, from those that don't, 
+because that's a way to reuse tests, but also because certainly it doesn't 
+hurt documentation either, and it's even better if it can influence how 
+abstractions are made.
+
+ _ _ __ ___ _____ ________ _____________ _____________________ ...
+| Mathieu Bouchard - tél:+1.514.383.3801 - http://artengine.ca/matju
+| Freelance Digital Arts Engineer, Montréal QC Canada
+
++-+-+--+---+-----+--------+-------------+---------------------+
+From matju@artengine.ca to pd-list on Dec 18, 2006
+
+I thought up some kind of classification of type systems, avoiding to call
+them strong/weak or static/dynamic because those words are confusing.
+
+1. Typed expressions: each piece of code that can give a value, has a
+type that can be figured out at compile-time.
+
+2. Typed variables/parameters: declarations allow runtime checks but not
+compile-time checks.
+
+3. Typed values: variables don't have types, they can contain any value,
+but every value has a type.
+
+4. Typed uses: values don't have types, a type is a way of using a value.
+
+Strictness, in the sense of forbidding things to the user, is not on that
+scale, it's another aspect. A well-balanced strictness allows one to
+bypass the system whenever needed, but without being too error-prone.
+
+However it's difficult to say what it means to "bypass the system" for all
+four typing categories at once, or even within one category.
+
+
++-+-+--+---+-----+--------+-------------+---------------------+
+From matju@artengine.ca to pd-dev on Jan 2, 2007
+
+PureUnity will now require pd 0.40. This will make things easier, as for
+example the aliases [f.inlet], [~.inlet] can be renamed to [inlet.f] and 
+[inlet.~], which makes those class-templates sortable alphabetically, and
+readable as "inlet of float" and "inlet of signal" or maybe "inlet for 
+floats" and "inlet for signals"... likewise for all other existing
+templates of PureUnity (do,norm,outlet,packunpack3,rand,swap,taa).
+
+(here, "template" means "parametrized classname" as in C++, and not t_template)
+
++-+-+--+---+-----+--------+-------------+---------------------+
+Old pre-DesireData ChangeLog for PureUnity:
+
+version 0.0 (2006.01.06):
+ * LICENSE is GPL
+ * doc is in README
+ * new object classes:
+   * [commutator],   [commutative-test]
+   * [associator],   [associative-test]
+   * [invertor],      [invertible-test]
+   * [distributor], [distributive-test]
+   * [trichotomy-test], ...
+   * [twice], [3times], [4times], [^]
+   * [tree], [protocols-tree]
+   * [rtimer]
+   * for $1 in f,~ and some of #:
+     [$1.norm], [$1.taa], [$1.do], [$1.packunpack3], [$1.swap]
+     [$1.inlet], [$1.outlet]
+
++-+-+--+---+-----+--------+-------------+---------------------+
diff --git a/desiredata/extra/pureunity/^.pd b/desiredata/extra/pureunity/^.pd
new file mode 100644
index 00000000..5050174f
--- /dev/null
+++ b/desiredata/extra/pureunity/^.pd
@@ -0,0 +1,25 @@
+#N canvas 0 0 361 237 10;
+#X obj 55 14 inlet;
+#X obj 55 154 outlet;
+#X obj 55 60 |;
+#X obj 85 60 &;
+#X obj 85 79 * -1;
+#X obj 85 98 + -1;
+#X obj 55 98 &;
+#X text 103 155 x or y but not both;
+#X text 112 61 both;
+#X text 118 89 not;
+#X text 30 98 but;
+#X text 9 61 either;
+#X obj 101 33 inlet;
+#X obj 55 33 t a a;
+#X connect 0 0 13 0;
+#X connect 2 0 6 0;
+#X connect 3 0 4 0;
+#X connect 4 0 5 0;
+#X connect 5 0 6 1;
+#X connect 6 0 1 0;
+#X connect 12 0 3 1;
+#X connect 12 0 2 1;
+#X connect 13 0 2 0;
+#X connect 13 1 3 0;
diff --git a/desiredata/extra/pureunity/antireflexive-test.pd b/desiredata/extra/pureunity/antireflexive-test.pd
new file mode 100644
index 00000000..7353dc64
--- /dev/null
+++ b/desiredata/extra/pureunity/antireflexive-test.pd
@@ -0,0 +1,13 @@
+#N canvas 0 0 450 164 10;
+#X obj 12 18 inlet;
+#X obj 12 118 outlet;
+#X obj 12 80 \$2;
+#X msg 12 37 2 2;
+#X obj 12 56 t a a;
+#X obj 12 99 == 0;
+#X connect 0 0 3 0;
+#X connect 2 0 5 0;
+#X connect 3 0 4 0;
+#X connect 4 0 2 0;
+#X connect 4 1 2 1;
+#X connect 5 0 1 0;
diff --git a/desiredata/extra/pureunity/antisymmetric-test.pd b/desiredata/extra/pureunity/antisymmetric-test.pd
new file mode 100644
index 00000000..0788ad61
--- /dev/null
+++ b/desiredata/extra/pureunity/antisymmetric-test.pd
@@ -0,0 +1,4 @@
+#N canvas 0 0 450 300 10;
+#X obj 12 18 inlet;
+#X obj 12 48 outlet;
+#X connect 0 0 1 0;
diff --git a/desiredata/extra/pureunity/arith-test.pd b/desiredata/extra/pureunity/arith-test.pd
new file mode 100644
index 00000000..6be56ea2
--- /dev/null
+++ b/desiredata/extra/pureunity/arith-test.pd
@@ -0,0 +1,76 @@
+#N canvas 69 22 726 501 10;
+#X text 78 136 Abelian Groups:;
+#X text 80 229 Abelian Monoids:;
+#X text 79 349 Rings (incl Fields):;
+#X obj 134 87 r \$0-b;
+#X obj 309 87 r \$0-b;
+#X obj 460 87 r \$0-b;
+#X obj 26 69 s \$0-b;
+#X obj 26 50 inlet bang;
+#X obj 14 464 r \$0-r;
+#X obj 14 483 outlet reports;
+#X obj 134 456 s \$0-r;
+#X obj 309 456 s \$0-r;
+#X obj 460 456 s \$0-r;
+#X obj 134 157 commutative-test \$1 +;
+#X obj 134 367 distributive-test \$1 + *;
+#X obj 134 177 commutative-test \$1 *;
+#X obj 134 197 commutative-test \$1 ^;
+#X obj 134 247 commutative-test \$1 &;
+#X obj 134 267 commutative-test \$1 |;
+#X obj 309 157 associative-test \$1 +;
+#X obj 460 157 invertible-test \$1 + -;
+#X text 17 11 This is the testclass for + \, - \, * \, / \, div \,
+pow \, % \, mod;
+#X obj 134 296 commutative-test \$1 min;
+#X obj 134 317 commutative-test \$1 max;
+#X text 18 25 And also for & \, | \, ^ \, min \, max;
+#X obj 134 387 distributive-test \$1 ^ &;
+#X obj 309 177 associative-test \$1 *;
+#X obj 309 247 associative-test \$1 &;
+#X obj 309 267 associative-test \$1 |;
+#X obj 309 197 associative-test \$1 ^;
+#X obj 309 296 associative-test \$1 min;
+#X obj 309 316 associative-test \$1 max;
+#X obj 460 177 invertible-test \$1 * /;
+#X obj 460 197 invertible-test \$1 ^ ^;
+#X connect 3 0 13 0;
+#X connect 3 0 14 0;
+#X connect 3 0 15 0;
+#X connect 3 0 16 0;
+#X connect 3 0 17 0;
+#X connect 3 0 18 0;
+#X connect 3 0 22 0;
+#X connect 3 0 23 0;
+#X connect 3 0 25 0;
+#X connect 4 0 19 0;
+#X connect 4 0 26 0;
+#X connect 4 0 27 0;
+#X connect 4 0 28 0;
+#X connect 4 0 29 0;
+#X connect 4 0 30 0;
+#X connect 4 0 31 0;
+#X connect 5 0 20 0;
+#X connect 5 0 32 0;
+#X connect 5 0 33 0;
+#X connect 7 0 6 0;
+#X connect 8 0 9 0;
+#X connect 13 0 10 0;
+#X connect 14 0 10 0;
+#X connect 15 0 10 0;
+#X connect 16 0 10 0;
+#X connect 17 0 10 0;
+#X connect 18 0 10 0;
+#X connect 19 0 11 0;
+#X connect 20 0 12 0;
+#X connect 22 0 10 0;
+#X connect 23 0 10 0;
+#X connect 25 0 10 0;
+#X connect 26 0 11 0;
+#X connect 27 0 11 0;
+#X connect 28 0 11 0;
+#X connect 29 0 11 0;
+#X connect 30 0 11 0;
+#X connect 31 0 11 0;
+#X connect 32 0 12 0;
+#X connect 33 0 12 0;
diff --git a/desiredata/extra/pureunity/associative-test.pd b/desiredata/extra/pureunity/associative-test.pd
new file mode 100644
index 00000000..80e3e0c5
--- /dev/null
+++ b/desiredata/extra/pureunity/associative-test.pd
@@ -0,0 +1,32 @@
+#N canvas 736 151 452 434 10;
+#X obj 40 15 inlet bang;
+#X obj 40 150 /;
+#X obj 40 169 t a a;
+#X text 167 24 with tolerance 0;
+#X obj 40 188 <= 0;
+#X text 167 9 This test verifies that (1+2)+3=1+(2+3);
+#X msg 40 34 1 2 3;
+#X obj 40 74 unpack 0 0 0;
+#X obj 40 245 outlet;
+#X obj 40 131 * 2;
+#X obj 40 93 associator \$1 \$2;
+#X obj 40 226 list append associative \$1 \$2;
+#X obj 40 207 pack 0 0 -1;
+#X obj 40 112 norm.\$1;
+#X obj 147 112 norm.\$1;
+#X connect 0 0 6 0;
+#X connect 1 0 2 0;
+#X connect 2 0 4 0;
+#X connect 2 1 12 1;
+#X connect 4 0 12 0;
+#X connect 6 0 7 0;
+#X connect 7 0 10 0;
+#X connect 7 1 10 1;
+#X connect 7 2 10 2;
+#X connect 9 0 1 0;
+#X connect 10 0 13 0;
+#X connect 10 1 14 0;
+#X connect 11 0 8 0;
+#X connect 12 0 11 0;
+#X connect 13 0 9 0;
+#X connect 14 0 1 1;
diff --git a/desiredata/extra/pureunity/associator.pd b/desiredata/extra/pureunity/associator.pd
new file mode 100644
index 00000000..f6592029
--- /dev/null
+++ b/desiredata/extra/pureunity/associator.pd
@@ -0,0 +1,38 @@
+#N canvas 574 54 580 317 10;
+#X text 245 40 when the associator is 0 the rule is respected.;
+#X text 245 63 see associative-test.pd;
+#X text 16 219 associator;
+#X text 166 219 antiassociator;
+#X text 244 25 (a*b)*c - a*(b*c) = 0;
+#X text 244 11 associativity rule for operator *=\$2 is:;
+#X obj 18 19 inlet.\$1 a;
+#X obj 91 19 inlet.\$1 b;
+#X obj 164 19 inlet.\$1 c;
+#X obj 18 61 packunpack3.\$1;
+#X obj 18 104 op2.\$1 \$2;
+#X obj 18 123 op2.\$1 \$2;
+#X obj 102 108 op2.\$1 \$2;
+#X obj 102 134 op2.\$1 \$2;
+#X obj 18 153 taa.\$1;
+#X obj 18 182 op2.\$1 -;
+#X obj 168 182 op2.\$1 +;
+#X obj 168 201 outlet.\$1 (ab)c+a(bc);
+#X obj 18 201 outlet.\$1 (ab)c-a(bc);
+#X connect 6 0 9 0;
+#X connect 7 0 9 1;
+#X connect 8 0 9 2;
+#X connect 9 0 10 0;
+#X connect 9 0 13 0;
+#X connect 9 1 10 1;
+#X connect 9 1 12 0;
+#X connect 9 2 11 1;
+#X connect 9 2 12 1;
+#X connect 10 0 11 0;
+#X connect 11 0 14 0;
+#X connect 12 0 13 1;
+#X connect 13 0 15 1;
+#X connect 13 0 16 1;
+#X connect 14 0 15 0;
+#X connect 14 1 16 0;
+#X connect 15 0 18 0;
+#X connect 16 0 17 0;
diff --git a/desiredata/extra/pureunity/commutative-test.pd b/desiredata/extra/pureunity/commutative-test.pd
new file mode 100644
index 00000000..1b4cb22e
--- /dev/null
+++ b/desiredata/extra/pureunity/commutative-test.pd
@@ -0,0 +1,39 @@
+#N canvas 555 5 452 322 10;
+#X obj 40 15 inlet bang;
+#X obj 101 102 unpack 0 0;
+#X obj 101 183 /;
+#X msg 40 34 1 3;
+#X text 216 9 This test verifies that 1+3=3+1;
+#X obj 101 202 t a a;
+#X obj 101 278 outlet;
+#X text 217 44 with tolerance 0;
+#X obj 101 221 <= 0;
+#X text 218 23 and 1*3=3*1 and...;
+#X obj 101 164 * 2;
+#X obj 101 126 commutator \$1 \$2;
+#X obj 41 53 t b l b;
+#X obj 43 95 realtime;
+#X floatatom 44 125 5 0 0 0 - - -;
+#X obj 101 259 list append commutative \$1 \$2;
+#X obj 101 240 pack 0 0 -1;
+#X obj 101 145 norm.\$1;
+#X obj 208 145 norm.\$1;
+#X connect 0 0 3 0;
+#X connect 1 0 11 0;
+#X connect 1 1 11 1;
+#X connect 2 0 5 0;
+#X connect 3 0 12 0;
+#X connect 5 0 8 0;
+#X connect 5 1 16 1;
+#X connect 8 0 16 0;
+#X connect 10 0 2 0;
+#X connect 11 0 17 0;
+#X connect 11 1 18 0;
+#X connect 12 0 13 1;
+#X connect 12 1 1 0;
+#X connect 12 2 13 0;
+#X connect 13 0 14 0;
+#X connect 15 0 6 0;
+#X connect 16 0 15 0;
+#X connect 17 0 10 0;
+#X connect 18 0 2 1;
diff --git a/desiredata/extra/pureunity/commutator.pd b/desiredata/extra/pureunity/commutator.pd
new file mode 100644
index 00000000..27a8e35e
--- /dev/null
+++ b/desiredata/extra/pureunity/commutator.pd
@@ -0,0 +1,41 @@
+#N canvas 394 81 620 407 10;
+#X text 90 114 ba;
+#X text 33 93 ab;
+#X text 220 113 however \, this thing i call commutator is more general
+;
+#X text 219 132 see commutative-test.pd;
+#X text 127 217 anticommutator;
+#X text 19 217 commutator;
+#X text 218 15 Say operator \$2 is *. Then the commutativity rule is:
+;
+#X text 218 32 a*b=b*a which is also a*b-b*a = 0;
+#X text 218 48 the commutator is a*b - b*a;
+#X text 219 72 when \$2=+ this is also known as a "group commutator"
+;
+#X text 219 92 when \$2=* this is also known as a "ring commutator"
+;
+#X obj 18 19 inlet.\$1 a;
+#X obj 93 19 inlet.\$1 b;
+#X obj 18 38 taa.\$1;
+#X obj 18 74 op2.\$1 \$2;
+#X obj 80 98 op2.\$1 \$2;
+#X obj 80 74 swap.\$1;
+#X obj 18 180 op2.\$1 -;
+#X obj 127 180 op2.\$1 +;
+#X obj 18 199 outlet.\$1 ab-ba;
+#X obj 127 199 outlet.\$1 ab+ba;
+#X obj 18 121 taa.\$1;
+#X connect 11 0 13 0;
+#X connect 12 0 14 1;
+#X connect 12 0 16 1;
+#X connect 13 0 14 0;
+#X connect 13 1 16 0;
+#X connect 14 0 21 0;
+#X connect 15 0 17 1;
+#X connect 15 0 18 0;
+#X connect 16 0 15 0;
+#X connect 16 1 15 1;
+#X connect 17 0 19 0;
+#X connect 18 0 20 0;
+#X connect 21 0 17 0;
+#X connect 21 1 18 1;
diff --git a/desiredata/extra/pureunity/comparators-test.pd b/desiredata/extra/pureunity/comparators-test.pd
new file mode 100644
index 00000000..f8b569ae
--- /dev/null
+++ b/desiredata/extra/pureunity/comparators-test.pd
@@ -0,0 +1,65 @@
+#N canvas 365 120 687 494 10;
+#X obj 134 87 r \$0-b;
+#X obj 329 87 r \$0-b;
+#X obj 26 69 s \$0-b;
+#X obj 26 50 inlet bang;
+#X obj 14 414 r \$0-r;
+#X obj 14 433 outlet reports;
+#X obj 134 406 s \$0-r;
+#X obj 329 406 s \$0-r;
+#X text 17 11 This is the testclass for == \, != \, < \, > \, <= \,
+>= \, && \, ||;
+#X obj 329 157 equivalence-test \$1 ==;
+#X obj 329 257 totalordereq-test \$1 == >=;
+#X obj 329 237 totalordereq-test \$1 == <=;
+#X obj 329 217 totalorder-test \$1 == >;
+#X obj 329 197 totalorder-test \$1 == <;
+#X obj 134 157 commutative-test \$1 ==;
+#X obj 134 177 commutative-test \$1 !=;
+#X obj 134 297 commutative-test \$1 &&;
+#X obj 134 317 commutative-test \$1 ||;
+#X obj 134 197 antisymmetric-test \$1 <;
+#X obj 134 217 antisymmetric-test \$1 >;
+#X obj 134 237 antisymmetric-test \$1 <=;
+#X obj 134 257 antisymmetric-test \$1 >=;
+#X obj 467 418 nbx 12 14 -1e+37 1e+37 0 0 empty empty empty 0 -6 0
+10 -262144 -1 -1 0 256;
+#X obj 467 382 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 329 297 associative-test \$1 &&;
+#X obj 329 317 associative-test \$1 ||;
+#X obj 467 399 rand.\$1;
+#X connect 0 0 14 0;
+#X connect 0 0 15 0;
+#X connect 0 0 16 0;
+#X connect 0 0 17 0;
+#X connect 0 0 18 0;
+#X connect 0 0 19 0;
+#X connect 0 0 20 0;
+#X connect 0 0 21 0;
+#X connect 1 0 9 0;
+#X connect 1 0 10 0;
+#X connect 1 0 11 0;
+#X connect 1 0 12 0;
+#X connect 1 0 13 0;
+#X connect 1 0 24 0;
+#X connect 1 0 25 0;
+#X connect 3 0 2 0;
+#X connect 4 0 5 0;
+#X connect 9 0 7 0;
+#X connect 10 0 7 0;
+#X connect 11 0 7 0;
+#X connect 12 0 7 0;
+#X connect 13 0 7 0;
+#X connect 14 0 6 0;
+#X connect 15 0 6 0;
+#X connect 16 0 6 0;
+#X connect 17 0 6 0;
+#X connect 18 0 6 0;
+#X connect 19 0 6 0;
+#X connect 20 0 6 0;
+#X connect 21 0 6 0;
+#X connect 23 0 26 0;
+#X connect 24 0 7 0;
+#X connect 25 0 7 0;
+#X connect 26 0 22 0;
diff --git a/desiredata/extra/pureunity/distributive-test.pd b/desiredata/extra/pureunity/distributive-test.pd
new file mode 100644
index 00000000..fd1e11d8
--- /dev/null
+++ b/desiredata/extra/pureunity/distributive-test.pd
@@ -0,0 +1,32 @@
+#N canvas 665 86 471 430 10;
+#X obj 40 15 inlet bang;
+#X obj 37 160 /;
+#X obj 37 179 t a a;
+#X text 157 24 with tolerance 0;
+#X obj 37 198 <= 0;
+#X text 156 9 This test verifies that 3*(4+5)=3*4+3*5;
+#X msg 40 34 3 4 5;
+#X obj 40 82 unpack 0 0 0;
+#X obj 37 255 outlet;
+#X obj 37 141 * 2;
+#X obj 37 103 distributor \$1 \$2 \$3;
+#X obj 37 236 list append distributive \$1 \$2 \$3;
+#X obj 37 217 pack 0 0 -1;
+#X obj 37 122 norm.\$1;
+#X obj 172 122 norm.\$1;
+#X connect 0 0 6 0;
+#X connect 1 0 2 0;
+#X connect 2 0 4 0;
+#X connect 2 1 12 1;
+#X connect 4 0 12 0;
+#X connect 6 0 7 0;
+#X connect 7 0 10 0;
+#X connect 7 1 10 1;
+#X connect 7 2 10 2;
+#X connect 9 0 1 0;
+#X connect 10 0 13 0;
+#X connect 10 1 14 0;
+#X connect 11 0 8 0;
+#X connect 12 0 11 0;
+#X connect 13 0 9 0;
+#X connect 14 0 1 1;
diff --git a/desiredata/extra/pureunity/distributor.pd b/desiredata/extra/pureunity/distributor.pd
new file mode 100644
index 00000000..b7cf2b3d
--- /dev/null
+++ b/desiredata/extra/pureunity/distributor.pd
@@ -0,0 +1,46 @@
+#N canvas 414 247 580 318 10;
+#X text 183 92 see distributive-test.pd;
+#X text 183 69 when the distributor is 0 the rule is respected.;
+#X text 16 269 distributor;
+#X text 180 269 antidistributor;
+#X text 182 40 distributivity rule for operator \$3 over operator \$2
+is:;
+#X text 182 54 a \$3 (b \$2 c) - ((a \$3 b) \$2 (a \$3 c)) = 0;
+#X obj 18 19 inlet.\$1 a;
+#X obj 91 19 inlet.\$1 b;
+#X obj 164 19 inlet.\$1 c;
+#X obj 18 61 packunpack3.\$1;
+#X obj 18 80 taa.\$1;
+#X obj 55 99 taa.\$1;
+#X obj 25 146 op2.\$1 \$2;
+#X obj 18 169 op2.\$1 \$3;
+#X obj 18 193 taa.\$1;
+#X obj 18 232 op2.\$1 -;
+#X obj 18 251 outlet.\$1 a(bc)-(ab+ac);
+#X obj 182 251 outlet.\$1 a(bc)+(ab+ac);
+#X obj 182 232 op2.\$1 +;
+#X obj 184 184 op2.\$1 \$3;
+#X obj 124 165 op2.\$1 \$3;
+#X obj 124 184 op2.\$1 \$2;
+#X connect 6 0 9 0;
+#X connect 7 0 9 1;
+#X connect 8 0 9 2;
+#X connect 9 0 10 0;
+#X connect 9 1 12 0;
+#X connect 9 1 20 1;
+#X connect 9 2 12 1;
+#X connect 9 2 19 1;
+#X connect 10 0 13 0;
+#X connect 10 1 11 0;
+#X connect 11 0 20 0;
+#X connect 11 1 19 0;
+#X connect 12 0 13 1;
+#X connect 13 0 14 0;
+#X connect 14 0 15 0;
+#X connect 14 1 18 0;
+#X connect 15 0 16 0;
+#X connect 18 0 17 0;
+#X connect 19 0 21 1;
+#X connect 20 0 21 0;
+#X connect 21 0 15 1;
+#X connect 21 0 18 1;
diff --git a/desiredata/extra/pureunity/equivalence-test.pd b/desiredata/extra/pureunity/equivalence-test.pd
new file mode 100644
index 00000000..d824510e
--- /dev/null
+++ b/desiredata/extra/pureunity/equivalence-test.pd
@@ -0,0 +1,14 @@
+#N canvas 0 0 450 161 10;
+#X obj 13 21 inlet;
+#X obj 13 121 outlet;
+#X obj 13 97 commutative-test \$1 \$2;
+#X obj 35 78 transitive-test \$1 \$2;
+#X obj 57 59 reflexive-test \$1 \$2;
+#X obj 13 40 t b b b;
+#X connect 0 0 5 0;
+#X connect 2 0 1 0;
+#X connect 3 0 1 0;
+#X connect 4 0 1 0;
+#X connect 5 0 2 0;
+#X connect 5 1 3 0;
+#X connect 5 2 4 0;
diff --git a/desiredata/extra/pureunity/glue-test.pd b/desiredata/extra/pureunity/glue-test.pd
new file mode 100644
index 00000000..7d3fa2aa
--- /dev/null
+++ b/desiredata/extra/pureunity/glue-test.pd
@@ -0,0 +1,15 @@
+#N canvas 185 138 665 479 10;
+#X obj 26 69 s \$0-b;
+#X obj 26 50 inlet bang;
+#X obj 14 414 r \$0-r;
+#X obj 14 433 outlet reports;
+#X obj 176 111 func2-test float;
+#X obj 176 131 func2-test symbol;
+#X obj 176 151 func2-test int;
+#X obj 176 91 func1-test bang;
+#X text 346 19 todo: send \, receive \, select \, route;
+#X text 346 32 todo: pack \, unpack \, trigger \, spigot;
+#X text 346 45 todo: moses \, until \, print \, makefilename;
+#X text 346 58 todo: change \, swap \, value;
+#X connect 1 0 0 0;
+#X connect 2 0 3 0;
diff --git a/desiredata/extra/pureunity/invertible-test.pd b/desiredata/extra/pureunity/invertible-test.pd
new file mode 100644
index 00000000..95703461
--- /dev/null
+++ b/desiredata/extra/pureunity/invertible-test.pd
@@ -0,0 +1,31 @@
+#N canvas 665 86 452 291 10;
+#X obj 40 15 inlet bang;
+#X obj 40 79 unpack 0 0;
+#X obj 33 160 /;
+#X msg 40 34 1 3;
+#X obj 33 179 t a a;
+#X text 217 24 with tolerance 0;
+#X obj 33 198 <= 0;
+#X text 215 9 This test verifies that 1+3-3=1;
+#X obj 33 255 outlet;
+#X obj 33 141 * 2;
+#X obj 33 103 invertor \$1 \$2 \$3;
+#X obj 33 236 list append invertible \$1 \$2 \$3;
+#X obj 33 217 pack 0 0 -1;
+#X obj 33 122 norm.\$1;
+#X obj 147 123 norm.\$1;
+#X connect 0 0 3 0;
+#X connect 1 0 10 0;
+#X connect 1 1 10 1;
+#X connect 2 0 4 0;
+#X connect 3 0 1 0;
+#X connect 4 0 6 0;
+#X connect 4 1 12 1;
+#X connect 6 0 12 0;
+#X connect 9 0 2 0;
+#X connect 10 0 13 0;
+#X connect 10 1 14 0;
+#X connect 11 0 8 0;
+#X connect 12 0 11 0;
+#X connect 13 0 9 0;
+#X connect 14 0 2 1;
diff --git a/desiredata/extra/pureunity/invertor.pd b/desiredata/extra/pureunity/invertor.pd
new file mode 100644
index 00000000..4ee54548
--- /dev/null
+++ b/desiredata/extra/pureunity/invertor.pd
@@ -0,0 +1,30 @@
+#N canvas 336 387 602 199 10;
+#X text 185 60 when the invertor is 0 the rule is respected.;
+#X text 185 83 see invertible-test.pd;
+#X text 19 174 invertor;
+#X text 149 174 antiinvertor;
+#X text 184 11 invertibility rule for operator \$2 with (presumed)
+right-inverse \$3 is:;
+#X text 184 45 (a \$2 b) \$3 b - a = 0;
+#X obj 18 19 inlet.\$1 a;
+#X obj 101 19 inlet.\$1 b;
+#X obj 18 39 taa.\$1;
+#X obj 18 65 op2.\$1 \$2;
+#X obj 18 91 op2.\$1 \$3;
+#X obj 18 115 taa.\$1;
+#X obj 18 137 op2.\$1 -;
+#X obj 18 156 outlet.\$1 (ab)/b-a;
+#X obj 148 156 outlet.\$1 (ab)/b+a;
+#X obj 148 137 op2.\$1 +;
+#X connect 6 0 8 0;
+#X connect 7 0 9 1;
+#X connect 7 0 10 1;
+#X connect 8 0 9 0;
+#X connect 8 1 12 1;
+#X connect 8 1 15 1;
+#X connect 9 0 10 0;
+#X connect 10 0 11 0;
+#X connect 11 0 12 0;
+#X connect 11 1 15 0;
+#X connect 12 0 13 0;
+#X connect 15 0 14 0;
diff --git a/desiredata/extra/pureunity/locale/english.tcl b/desiredata/extra/pureunity/locale/english.tcl
new file mode 100644
index 00000000..8dca411d
--- /dev/null
+++ b/desiredata/extra/pureunity/locale/english.tcl
@@ -0,0 +1,56 @@
+
+say_namespace summary {
+  foreach {x y} {
+    f "floating-point"
+    ~ "signal"
+    \# "grid"
+  } {
+    say_category basic<$x>
+    say $x.do " ($y)"
+    say $x.norm " ($y)"
+    say $x.packunpack3 " ($y)"
+    say $x.swap " ($y)"
+    say $x.taa " ($y)"
+  }
+
+  say_category interfaces
+  proc pu_say {} {
+  }
+
+  pu_say   antireflexive {t  } ""
+  pu_say       reflexive {t  } ""
+
+  pu_say     commutative {t  } ""
+  pu_say anticommutative {t  } ""
+  pu_say   antisymmetric {t  } ""
+
+  pu_say     associative {t  } ""
+  pu_say    distributive {t  } ""
+  pu_say      invertible {t  } ""
+
+  pu_say  partialorder   {t  } "partial order (open)"
+  pu_say  partialordereq {t  } "partial order (closed)"
+  pu_say    totalorder   {t  } "total order (open)"
+  pu_say    totalordereq {t  } "total order (closed)"
+  pu_say     equivalence {t  } "equivalence relation"
+
+  pu_say      transitive {t  } "transitive: "
+  pu_say      trichotomy {t  } "trichotomy: either equal or less or greater"
+  pu_say       operator1 {t  } "1-input operator"
+  pu_say       operator2 {t  } "2-input operator"
+
+  say_category cancellators
+  say  associator "(ab)c-a(bc)"
+  say  commutator "ab-ba"
+  say distributor "a&(b^c)-(ab^ac)"
+  say    invertor "ab/b-a"
+
+  say_category misc
+  say twice ""
+  say 3times ""
+  say 4times ""
+  say ^ "xor"
+  say error ""
+  say protocols-tree ""
+  say tree ""
+}
diff --git a/desiredata/extra/pureunity/main.pd b/desiredata/extra/pureunity/main.pd
new file mode 100644
index 00000000..fb8f27ee
--- /dev/null
+++ b/desiredata/extra/pureunity/main.pd
@@ -0,0 +1,90 @@
+#N canvas 732 0 490 486 10;
+#X obj 19 65 loadbang;
+#X obj 28 87 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 41 373 print;
+#N canvas 509 382 450 300 other 0;
+#X obj 20 38 2times symbol foo bar;
+#X obj 20 21 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 20 57 print;
+#X obj 20 81 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 20 117 print;
+#X obj 20 98 3times symbol foo bar baz;
+#X obj 20 141 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 20 177 print;
+#X obj 20 158 4times symbol foo bar baz fnord;
+#X connect 0 0 2 0;
+#X connect 1 0 0 0;
+#X connect 3 0 5 0;
+#X connect 5 0 4 0;
+#X connect 6 0 8 0;
+#X connect 8 0 7 0;
+#X restore 345 56 pd other;
+#X obj 19 111 t b b b;
+#X obj 71 354 +;
+#X msg 121 354 0;
+#X msg 71 316 float \$1;
+#X obj 41 297 t a a;
+#X obj 96 354 t f;
+#X obj 19 346 f;
+#X obj 71 335 == 0;
+#X obj 19 392 print total_failures;
+#X obj 226 251 sel 0;
+#X obj 234 312 bng 100 250 50 0 empty empty empty 0 -6 0 8 -258699
+-1 -262144;
+#X msg 234 293 color \$1 \, bang;
+#X msg 226 270 16;
+#X msg 256 270 13;
+#X text 24 437 This does not count errors not reported by the tests
+;
+#X text 25 464 Consult the console for more information;
+#X obj 4 7 cnv 15 500 40 empty empty PureUnity 8 20 1 18 -34345 -68160
+0;
+#X text 130 7 TM;
+#X obj 15 35 cnv 1 480 1 empty empty Copyright_2006-2007_by_Mathieu_Bouchard
+150 -5 1 9 -258699 -262144 0;
+#X text 25 450 Such as Syntax Error \, Class Not Found \, etc.;
+#X text 297 253 Green: PASS;
+#X text 311 265 Red: FAIL;
+#X obj 85 150 glue-test;
+#X obj 41 131 t b b b;
+#X text 6 48 from the bit rot prevention department;
+#X obj 284 168 print;
+#X symbolatom 284 133 10 0 0 0 - - -;
+#X msg 284 114 symbol field;
+#X obj 63 169 arith-test f;
+#X obj 41 188 comparators-test f;
+#X text 209 96 type in the name of an interface;
+#X obj 284 149 protocols-tree;
+#X connect 0 0 4 0;
+#X connect 1 0 4 0;
+#X connect 4 0 10 0;
+#X connect 4 1 27 0;
+#X connect 4 2 6 0;
+#X connect 5 0 9 0;
+#X connect 5 0 10 1;
+#X connect 6 0 5 1;
+#X connect 7 0 11 0;
+#X connect 8 0 2 0;
+#X connect 8 1 7 0;
+#X connect 9 0 5 1;
+#X connect 10 0 12 0;
+#X connect 10 0 13 0;
+#X connect 11 0 5 0;
+#X connect 13 0 16 0;
+#X connect 13 1 17 0;
+#X connect 15 0 14 0;
+#X connect 16 0 15 0;
+#X connect 17 0 15 0;
+#X connect 26 0 8 0;
+#X connect 27 0 33 0;
+#X connect 27 1 32 0;
+#X connect 27 2 26 0;
+#X connect 30 0 35 0;
+#X connect 31 0 30 0;
+#X connect 32 0 8 0;
+#X connect 33 0 8 0;
+#X connect 35 0 29 0;
diff --git a/desiredata/extra/pureunity/norm.#.pd b/desiredata/extra/pureunity/norm.#.pd
new file mode 100644
index 00000000..d4fc6cef
--- /dev/null
+++ b/desiredata/extra/pureunity/norm.#.pd
@@ -0,0 +1,8 @@
+#N canvas 0 0 450 300 10;
+#X obj 21 24 inlet;
+#X obj 20 50 # sq;
+#X obj 20 80 #ravel;
+#X obj 21 111 #fold +;
+#X obj 21 139 #export;
+#X obj 22 170 sqrt;
+#X obj 22 201 outlet;
diff --git a/desiredata/extra/pureunity/norm.f.pd b/desiredata/extra/pureunity/norm.f.pd
new file mode 100644
index 00000000..305f4ac1
--- /dev/null
+++ b/desiredata/extra/pureunity/norm.f.pd
@@ -0,0 +1,8 @@
+#N canvas 462 350 544 148 10;
+#X obj 23 20 inlet f;
+#X obj 23 58 outlet f;
+#X text 101 18 \$1.norm takes a value of type \$1 and produces a nonnegative
+float \, normally using L2-norm formulas;
+#X obj 23 39 abs;
+#X connect 0 0 3 0;
+#X connect 3 0 1 0;
diff --git a/desiredata/extra/pureunity/norm.~.pd b/desiredata/extra/pureunity/norm.~.pd
new file mode 100644
index 00000000..d429fc17
--- /dev/null
+++ b/desiredata/extra/pureunity/norm.~.pd
@@ -0,0 +1,8 @@
+#N canvas 462 350 544 148 10;
+#X obj 23 20 inlet~ f;
+#X obj 23 58 outlet f;
+#X text 101 18 \$1.norm takes a value of type \$1 and produces a nonnegative
+float \, normally using L2-norm formulas;
+#X obj 23 39 env~;
+#X connect 0 0 3 0;
+#X connect 3 0 1 0;
diff --git a/desiredata/extra/pureunity/op2.#.pd b/desiredata/extra/pureunity/op2.#.pd
new file mode 100644
index 00000000..ee1ce083
--- /dev/null
+++ b/desiredata/extra/pureunity/op2.#.pd
@@ -0,0 +1,8 @@
+#N canvas 385 252 450 129 10;
+#X obj 21 34 inlet;
+#X obj 61 34 inlet;
+#X obj 21 82 outlet;
+#X obj 21 59 # \$1 \$2;
+#X connect 0 0 3 0;
+#X connect 1 0 3 1;
+#X connect 3 0 2 0;
diff --git a/desiredata/extra/pureunity/op2.f.pd b/desiredata/extra/pureunity/op2.f.pd
new file mode 100644
index 00000000..7e01d641
--- /dev/null
+++ b/desiredata/extra/pureunity/op2.f.pd
@@ -0,0 +1,8 @@
+#N canvas 324 321 451 124 10;
+#X obj 19 18 inlet;
+#X obj 69 18 inlet;
+#X obj 19 50 \$1 \$2;
+#X obj 19 84 outlet;
+#X connect 0 0 2 0;
+#X connect 1 0 2 1;
+#X connect 2 0 3 0;
diff --git a/desiredata/extra/pureunity/op2.~.pd b/desiredata/extra/pureunity/op2.~.pd
new file mode 100644
index 00000000..97c09c7f
--- /dev/null
+++ b/desiredata/extra/pureunity/op2.~.pd
@@ -0,0 +1,8 @@
+#N canvas 338 329 450 125 10;
+#X obj 19 50 \$1~ \$2;
+#X obj 19 18 inlet~;
+#X obj 69 18 inlet~;
+#X obj 19 84 outlet~;
+#X connect 0 0 3 0;
+#X connect 1 0 0 0;
+#X connect 2 0 0 1;
diff --git a/desiredata/extra/pureunity/operator1-rule.pd b/desiredata/extra/pureunity/operator1-rule.pd
new file mode 100644
index 00000000..f9d91e03
--- /dev/null
+++ b/desiredata/extra/pureunity/operator1-rule.pd
@@ -0,0 +1,11 @@
+#N canvas 0 0 450 142 10;
+#X obj 15 16 inlet;
+#X obj 37 104 outlet;
+#X text 57 17 Test that one input gives one output;
+#X obj 37 84 \$1;
+#X obj 87 104 outlet;
+#X obj 15 55 t b a b;
+#X obj 242 63 error;
+#X connect 0 0 5 0;
+#X connect 3 0 1 0;
+#X connect 5 1 3 0;
diff --git a/desiredata/extra/pureunity/operator1-test.pd b/desiredata/extra/pureunity/operator1-test.pd
new file mode 100644
index 00000000..ed7f0fb4
--- /dev/null
+++ b/desiredata/extra/pureunity/operator1-test.pd
@@ -0,0 +1,5 @@
+#N canvas 0 0 450 142 10;
+#X obj 15 16 inlet;
+#X obj 15 94 outlet;
+#X text 57 17 Test that one input gives one output;
+#X connect 0 0 1 0;
diff --git a/desiredata/extra/pureunity/operator2-rule.pd b/desiredata/extra/pureunity/operator2-rule.pd
new file mode 100644
index 00000000..8ef1f7f1
--- /dev/null
+++ b/desiredata/extra/pureunity/operator2-rule.pd
@@ -0,0 +1,10 @@
+#N canvas 248 186 450 162 10;
+#X obj 15 16 inlet;
+#X obj 15 94 outlet;
+#X obj 54 35 func1-test \$1 \$2;
+#X text 74 55 And test that one right input gives zero output;
+#X obj 15 35 t a a;
+#X connect 0 0 4 0;
+#X connect 2 0 1 0;
+#X connect 4 0 1 0;
+#X connect 4 1 2 0;
diff --git a/desiredata/extra/pureunity/operator2-test.pd b/desiredata/extra/pureunity/operator2-test.pd
new file mode 100644
index 00000000..8ef1f7f1
--- /dev/null
+++ b/desiredata/extra/pureunity/operator2-test.pd
@@ -0,0 +1,10 @@
+#N canvas 248 186 450 162 10;
+#X obj 15 16 inlet;
+#X obj 15 94 outlet;
+#X obj 54 35 func1-test \$1 \$2;
+#X text 74 55 And test that one right input gives zero output;
+#X obj 15 35 t a a;
+#X connect 0 0 4 0;
+#X connect 2 0 1 0;
+#X connect 4 0 1 0;
+#X connect 4 1 2 0;
diff --git a/desiredata/extra/pureunity/packunpack3.#.pd b/desiredata/extra/pureunity/packunpack3.#.pd
new file mode 100644
index 00000000..3c182771
--- /dev/null
+++ b/desiredata/extra/pureunity/packunpack3.#.pd
@@ -0,0 +1,18 @@
+#N canvas 622 298 449 167 10;
+#X obj 105 127 outlet;
+#X obj 115 14 inlet;
+#X obj 69 14 inlet;
+#X obj 59 127 outlet;
+#X obj 13 127 outlet;
+#X obj 13 14 inlet;
+#X obj 84 64 #store;
+#X obj 38 64 #store;
+#X obj 13 33 t a b b;
+#X connect 1 0 6 1;
+#X connect 2 0 7 1;
+#X connect 5 0 8 0;
+#X connect 6 0 0 0;
+#X connect 7 0 3 0;
+#X connect 8 0 4 0;
+#X connect 8 1 7 0;
+#X connect 8 2 6 0;
diff --git a/desiredata/extra/pureunity/packunpack3.f.pd b/desiredata/extra/pureunity/packunpack3.f.pd
new file mode 100644
index 00000000..7343d5f3
--- /dev/null
+++ b/desiredata/extra/pureunity/packunpack3.f.pd
@@ -0,0 +1,16 @@
+#N canvas 285 202 449 125 10;
+#X obj 106 87 outlet;
+#X obj 105 14 inlet;
+#X obj 59 14 inlet;
+#X obj 60 87 outlet;
+#X obj 14 87 outlet;
+#X obj 13 14 inlet;
+#X obj 27 41 pack 0 0 0;
+#X obj 27 60 unpack 0 0 0;
+#X connect 1 0 6 2;
+#X connect 2 0 6 1;
+#X connect 5 0 6 0;
+#X connect 6 0 7 0;
+#X connect 7 0 4 0;
+#X connect 7 1 3 0;
+#X connect 7 2 0 0;
diff --git a/desiredata/extra/pureunity/packunpack3.~.pd b/desiredata/extra/pureunity/packunpack3.~.pd
new file mode 100644
index 00000000..7171a98e
--- /dev/null
+++ b/desiredata/extra/pureunity/packunpack3.~.pd
@@ -0,0 +1,10 @@
+#N canvas 285 202 449 67 10;
+#X obj 13 14 inlet~;
+#X obj 13 34 outlet~;
+#X obj 73 14 inlet~;
+#X obj 73 34 outlet~;
+#X obj 133 14 inlet~;
+#X obj 133 34 outlet~;
+#X connect 0 0 1 0;
+#X connect 2 0 3 0;
+#X connect 4 0 5 0;
diff --git a/desiredata/extra/pureunity/partialorder-test.pd b/desiredata/extra/pureunity/partialorder-test.pd
new file mode 100644
index 00000000..65aff88c
--- /dev/null
+++ b/desiredata/extra/pureunity/partialorder-test.pd
@@ -0,0 +1,14 @@
+#N canvas 118 56 450 189 10;
+#X obj 13 21 inlet;
+#X obj 13 141 outlet;
+#X obj 35 87 transitive-test \$1 \$2;
+#X obj 13 107 antisymmetric-test \$1 \$2;
+#X obj 57 67 antireflexive-test \$1 \$2;
+#X obj 13 41 t b b b;
+#X connect 0 0 5 0;
+#X connect 2 0 1 0;
+#X connect 3 0 1 0;
+#X connect 4 0 1 0;
+#X connect 5 0 3 0;
+#X connect 5 1 2 0;
+#X connect 5 2 4 0;
diff --git a/desiredata/extra/pureunity/partialordereq-test.pd b/desiredata/extra/pureunity/partialordereq-test.pd
new file mode 100644
index 00000000..39de970a
--- /dev/null
+++ b/desiredata/extra/pureunity/partialordereq-test.pd
@@ -0,0 +1,14 @@
+#N canvas 118 56 450 182 10;
+#X obj 13 21 inlet;
+#X obj 13 131 outlet;
+#X obj 35 79 transitive-test \$1 \$2;
+#X obj 57 60 reflexive-test \$1 \$2;
+#X obj 13 98 antisymmetric-test \$1 \$2;
+#X obj 13 40 t b b b;
+#X connect 0 0 5 0;
+#X connect 2 0 1 0;
+#X connect 3 0 1 0;
+#X connect 4 0 1 0;
+#X connect 5 0 4 0;
+#X connect 5 1 2 0;
+#X connect 5 2 3 0;
diff --git a/desiredata/extra/pureunity/protocols-tree.pd b/desiredata/extra/pureunity/protocols-tree.pd
new file mode 100644
index 00000000..0d0bba9e
--- /dev/null
+++ b/desiredata/extra/pureunity/protocols-tree.pd
@@ -0,0 +1,65 @@
+#N canvas 132 109 813 546 10;
+#X obj 13 466 r \$0-out;
+#X obj 13 485 outlet;
+#X text 20 15 the direction of flow indicates "inherits from";
+#X obj 208 110 tree \$0 commutative;
+#X obj 13 390 makefilename \$0-%s;
+#X obj 13 371 inlet symbol;
+#X text 7 508 output is a sequence of begin \$1 and end \$1 messages
+that indicate a hierarchy.;
+#X text 36 447 send to a certain tree object;
+#X obj 13 409 t b s;
+#X obj 13 447 s;
+#X obj 13 428 symbol \$0-out;
+#X obj 423 157 tree \$0 reflexive;
+#X obj 594 157 tree \$0 antireflexive;
+#X obj 423 135 tree \$0 partialorder;
+#X obj 594 135 tree \$0 partialordereq;
+#X obj 423 90 tree \$0 totalorder;
+#X obj 594 81 tree \$0 totalordereq;
+#X obj 380 54 tree \$0 equivalence;
+#X obj 458 455 tree \$0 associative;
+#X obj 486 355 tree \$0 distributive;
+#X obj 474 409 tree \$0 invertible;
+#X obj 512 115 tree \$0 trichotomy;
+#X obj 380 220 tree \$0 transitive;
+#X obj 458 436 tree \$0 semigroup ?;
+#X obj 458 381 tree \$0 group ?;
+#X obj 622 184 tree \$0 antisymmetric2 ?;
+#X obj 480 330 tree \$0 ring ?;
+#X obj 432 185 tree \$0 antisymmetric ?;
+#X obj 208 130 tree \$0 anticommutative;
+#X obj 480 310 tree \$0 field ?;
+#X obj 423 276 tree \$0 relation;
+#X obj 662 288 tree \$0 unpacklike;
+#X obj 662 311 tree \$0 packlike;
+#X obj 667 348 tree \$0 operator1;
+#X obj 667 368 tree \$0 operator2;
+#X connect 0 0 1 0;
+#X connect 4 0 8 0;
+#X connect 5 0 4 0;
+#X connect 8 0 10 0;
+#X connect 8 1 9 1;
+#X connect 10 0 9 0;
+#X connect 11 0 30 0;
+#X connect 12 0 25 0;
+#X connect 12 0 30 0;
+#X connect 13 0 11 0;
+#X connect 13 0 22 0;
+#X connect 13 0 27 0;
+#X connect 14 0 12 0;
+#X connect 14 0 22 0;
+#X connect 15 0 13 0;
+#X connect 15 0 21 0;
+#X connect 16 0 14 0;
+#X connect 16 0 21 0;
+#X connect 17 0 3 0;
+#X connect 17 0 11 0;
+#X connect 17 0 22 0;
+#X connect 22 0 30 0;
+#X connect 23 0 18 0;
+#X connect 24 0 20 0;
+#X connect 24 0 23 0;
+#X connect 26 0 19 0;
+#X connect 26 0 24 0;
+#X connect 29 0 26 0;
diff --git a/desiredata/extra/pureunity/pureunity.c b/desiredata/extra/pureunity/pureunity.c
new file mode 100644
index 00000000..2c7e2fcf
--- /dev/null
+++ b/desiredata/extra/pureunity/pureunity.c
@@ -0,0 +1,37 @@
+/*
+	$Id: pureunity.c,v 1.1.2.3 2007-06-28 03:21:16 matju Exp $
+	PureUnity
+	Copyright 2006 by Mathieu Bouchard <matju à artengine point ca>
+
+	This program is free software; you can redistribute it and/or
+	modify it under the terms of the GNU General Public License
+	as published by the Free Software Foundation; either version 2
+	of the License, or (at your option) any later version.
+
+	See file ./COPYING for further informations on licensing terms.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+#include <sys/time.h>
+#include "../../src/m_pd.h"
+#define ALIAS(y,x) class_addcreator((t_newmethod)getfn(m,gensym(x)),gensym(y),A_GIMME,0);
+
+void pureunity_setup() {
+	t_pd *m = &pd_objectmaker;
+	ALIAS( "inlet.f","inlet"  );
+	ALIAS( "inlet.#","inlet"  );
+	ALIAS( "inlet.~","inlet~" );
+	ALIAS("outlet.f","outlet" );
+	ALIAS("outlet.#","outlet" );
+	ALIAS("outlet.~","outlet~");
+	ALIAS(  "f.swap","swap"   );
+}
+
diff --git a/desiredata/extra/pureunity/rand.#.pd b/desiredata/extra/pureunity/rand.#.pd
new file mode 100644
index 00000000..ce3d3c91
--- /dev/null
+++ b/desiredata/extra/pureunity/rand.#.pd
@@ -0,0 +1,42 @@
+#N canvas 0 0 450 300 10;
+#X obj 21 34 inlet;
+#X obj 21 223 *;
+#X obj 73 95 random 256;
+#X obj 183 87 random;
+#X msg 220 39 1;
+#X obj 220 20 loadbang;
+#X obj 220 58 << 23;
+#X obj 183 106 +;
+#X obj 21 53 t b b b;
+#X obj 21 136 random 2;
+#X obj 21 174 - 1;
+#X obj 73 114 - 150;
+#X obj 43 114 pow;
+#X obj 21 242 outlet;
+#X obj 43 76 t b b;
+#X msg 43 95 2;
+#X obj 21 199 *;
+#X obj 21 155 * 2;
+#X text 125 205 Should this actually produce a grid or not?...;
+#X text 126 221 Whatever does the job...;
+#X connect 0 0 8 0;
+#X connect 1 0 13 0;
+#X connect 2 0 11 0;
+#X connect 3 0 7 0;
+#X connect 4 0 6 0;
+#X connect 5 0 4 0;
+#X connect 6 0 3 1;
+#X connect 6 0 7 1;
+#X connect 7 0 16 1;
+#X connect 8 0 9 0;
+#X connect 8 1 14 0;
+#X connect 8 2 3 0;
+#X connect 9 0 17 0;
+#X connect 10 0 16 0;
+#X connect 11 0 12 1;
+#X connect 12 0 1 1;
+#X connect 14 0 15 0;
+#X connect 14 1 2 0;
+#X connect 15 0 12 0;
+#X connect 16 0 1 0;
+#X connect 17 0 10 0;
diff --git a/desiredata/extra/pureunity/rand.f.pd b/desiredata/extra/pureunity/rand.f.pd
new file mode 100644
index 00000000..f4372dc0
--- /dev/null
+++ b/desiredata/extra/pureunity/rand.f.pd
@@ -0,0 +1,40 @@
+#N canvas 0 0 450 300 10;
+#X obj 11 14 inlet;
+#X obj 11 192 *;
+#X obj 63 75 random 256;
+#X obj 183 87 random;
+#X msg 220 39 1;
+#X obj 220 20 loadbang;
+#X obj 220 58 << 23;
+#X obj 183 106 +;
+#X obj 11 33 t b b b;
+#X obj 11 116 random 2;
+#X obj 11 154 - 1;
+#X obj 63 94 - 150;
+#X obj 33 94 pow;
+#X obj 11 211 outlet;
+#X obj 33 56 t b b;
+#X msg 33 75 2;
+#X obj 11 173 *;
+#X obj 11 135 * 2;
+#X connect 0 0 8 0;
+#X connect 1 0 13 0;
+#X connect 2 0 11 0;
+#X connect 3 0 7 0;
+#X connect 4 0 6 0;
+#X connect 5 0 4 0;
+#X connect 6 0 3 1;
+#X connect 6 0 7 1;
+#X connect 7 0 16 1;
+#X connect 8 0 9 0;
+#X connect 8 1 14 0;
+#X connect 8 2 3 0;
+#X connect 9 0 17 0;
+#X connect 10 0 16 0;
+#X connect 11 0 12 1;
+#X connect 12 0 1 1;
+#X connect 14 0 15 0;
+#X connect 14 1 2 0;
+#X connect 15 0 12 0;
+#X connect 16 0 1 0;
+#X connect 17 0 10 0;
diff --git a/desiredata/extra/pureunity/rand.~.pd b/desiredata/extra/pureunity/rand.~.pd
new file mode 100644
index 00000000..cb1bf37b
--- /dev/null
+++ b/desiredata/extra/pureunity/rand.~.pd
@@ -0,0 +1,22 @@
+#N canvas 339 187 450 177 10;
+#X obj 105 118 pow;
+#X obj 105 80 t b b;
+#X msg 105 99 2;
+#X obj 22 98 env~;
+#X obj 11 14 inlet;
+#X obj 10 143 outlet~;
+#X text 52 14 banging the inlet does nothing for signals.;
+#X obj 37 62 noise~;
+#X obj 135 99 random 64;
+#X obj 135 118 - 64;
+#X obj 11 62 *~;
+#X connect 0 0 10 0;
+#X connect 1 0 2 0;
+#X connect 1 1 8 0;
+#X connect 2 0 0 0;
+#X connect 3 0 1 0;
+#X connect 7 0 10 1;
+#X connect 8 0 9 0;
+#X connect 9 0 0 1;
+#X connect 10 0 5 0;
+#X connect 10 0 3 0;
diff --git a/desiredata/extra/pureunity/reflexive-test.pd b/desiredata/extra/pureunity/reflexive-test.pd
new file mode 100644
index 00000000..1ae836d0
--- /dev/null
+++ b/desiredata/extra/pureunity/reflexive-test.pd
@@ -0,0 +1,13 @@
+#N canvas 0 0 450 161 10;
+#X obj 12 18 inlet;
+#X obj 12 120 outlet;
+#X obj 12 56 t a a;
+#X msg 12 37 2 2;
+#X obj 12 82 \$2;
+#X obj 12 101 == 1;
+#X connect 0 0 3 0;
+#X connect 2 0 4 0;
+#X connect 2 1 4 1;
+#X connect 3 0 2 0;
+#X connect 4 0 5 0;
+#X connect 5 0 1 0;
diff --git a/desiredata/extra/pureunity/swap.#.pd b/desiredata/extra/pureunity/swap.#.pd
new file mode 100644
index 00000000..2865b5a3
--- /dev/null
+++ b/desiredata/extra/pureunity/swap.#.pd
@@ -0,0 +1,14 @@
+#N canvas 0 0 450 125 10;
+#X obj 12 72 #store;
+#X obj 12 34 t a a;
+#X obj 12 53 #finished;
+#X obj 12 15 inlet a;
+#X obj 58 72 inlet b;
+#X obj 12 91 outlet b;
+#X obj 51 34 outlet a;
+#X connect 0 0 5 0;
+#X connect 1 0 2 0;
+#X connect 1 1 6 0;
+#X connect 2 0 0 0;
+#X connect 3 0 1 0;
+#X connect 4 0 0 1;
diff --git a/desiredata/extra/pureunity/swap.f.pd b/desiredata/extra/pureunity/swap.f.pd
new file mode 100644
index 00000000..1215b477
--- /dev/null
+++ b/desiredata/extra/pureunity/swap.f.pd
@@ -0,0 +1,10 @@
+#N canvas 218 156 450 98 10;
+#X obj 14 11 inlet~;
+#X obj 74 11 inlet~;
+#X obj 14 61 outlet~;
+#X obj 74 61 outlet~;
+#X obj 14 37 swap;
+#X connect 0 0 4 0;
+#X connect 1 0 4 1;
+#X connect 4 0 2 0;
+#X connect 4 1 3 0;
diff --git a/desiredata/extra/pureunity/swap.~.pd b/desiredata/extra/pureunity/swap.~.pd
new file mode 100644
index 00000000..8055ea0c
--- /dev/null
+++ b/desiredata/extra/pureunity/swap.~.pd
@@ -0,0 +1,7 @@
+#N canvas 218 156 450 98 10;
+#X obj 14 11 inlet~;
+#X obj 74 11 inlet~;
+#X obj 14 61 outlet~;
+#X obj 74 61 outlet~;
+#X connect 0 0 3 0;
+#X connect 1 0 2 0;
diff --git a/desiredata/extra/pureunity/taa.#.pd b/desiredata/extra/pureunity/taa.#.pd
new file mode 100644
index 00000000..ae3b4b1c
--- /dev/null
+++ b/desiredata/extra/pureunity/taa.#.pd
@@ -0,0 +1,8 @@
+#N canvas 353 249 367 122 10;
+#X obj 19 14 inlet;
+#X obj 19 71 outlet;
+#X obj 19 33 t a a;
+#X obj 49 52 outlet;
+#X connect 0 0 2 0;
+#X connect 2 0 1 0;
+#X connect 2 1 3 0;
diff --git a/desiredata/extra/pureunity/taa.f.pd b/desiredata/extra/pureunity/taa.f.pd
new file mode 100644
index 00000000..ae3b4b1c
--- /dev/null
+++ b/desiredata/extra/pureunity/taa.f.pd
@@ -0,0 +1,8 @@
+#N canvas 353 249 367 122 10;
+#X obj 19 14 inlet;
+#X obj 19 71 outlet;
+#X obj 19 33 t a a;
+#X obj 49 52 outlet;
+#X connect 0 0 2 0;
+#X connect 2 0 1 0;
+#X connect 2 1 3 0;
diff --git a/desiredata/extra/pureunity/taa.~.pd b/desiredata/extra/pureunity/taa.~.pd
new file mode 100644
index 00000000..7f52b01a
--- /dev/null
+++ b/desiredata/extra/pureunity/taa.~.pd
@@ -0,0 +1,6 @@
+#N canvas 353 249 367 122 10;
+#X obj 19 14 inlet~;
+#X obj 49 52 outlet~;
+#X obj 19 71 outlet~;
+#X connect 0 0 1 0;
+#X connect 0 0 2 0;
diff --git a/desiredata/extra/pureunity/totalorder-test.pd b/desiredata/extra/pureunity/totalorder-test.pd
new file mode 100644
index 00000000..9aa72fce
--- /dev/null
+++ b/desiredata/extra/pureunity/totalorder-test.pd
@@ -0,0 +1,11 @@
+#N canvas 118 56 418 157 10;
+#X obj 13 21 inlet;
+#X obj 13 101 outlet;
+#X obj 43 59 partialorder-test \$1 \$2;
+#X obj 13 78 trichotomy-test \$1 \$2;
+#X obj 13 40 t b b;
+#X connect 0 0 4 0;
+#X connect 2 0 1 0;
+#X connect 3 0 1 0;
+#X connect 4 0 3 0;
+#X connect 4 1 2 0;
diff --git a/desiredata/extra/pureunity/totalordereq-test.pd b/desiredata/extra/pureunity/totalordereq-test.pd
new file mode 100644
index 00000000..4c7372d6
--- /dev/null
+++ b/desiredata/extra/pureunity/totalordereq-test.pd
@@ -0,0 +1,11 @@
+#N canvas 349 136 450 153 10;
+#X obj 13 21 inlet;
+#X obj 13 97 outlet;
+#X obj 13 78 trichotomy-test \$1 \$2;
+#X obj 43 59 partialordereq-test \$1 \$2;
+#X obj 13 40 t b b;
+#X connect 0 0 4 0;
+#X connect 2 0 1 0;
+#X connect 3 0 1 0;
+#X connect 4 0 2 0;
+#X connect 4 1 3 0;
diff --git a/desiredata/extra/pureunity/transitive-test.pd b/desiredata/extra/pureunity/transitive-test.pd
new file mode 100644
index 00000000..0788ad61
--- /dev/null
+++ b/desiredata/extra/pureunity/transitive-test.pd
@@ -0,0 +1,4 @@
+#N canvas 0 0 450 300 10;
+#X obj 12 18 inlet;
+#X obj 12 48 outlet;
+#X connect 0 0 1 0;
diff --git a/desiredata/extra/pureunity/tree.pd b/desiredata/extra/pureunity/tree.pd
new file mode 100644
index 00000000..ae9d3d89
--- /dev/null
+++ b/desiredata/extra/pureunity/tree.pd
@@ -0,0 +1,20 @@
+#N canvas 415 303 474 293 10;
+#X obj 51 61 symbol \$2;
+#X obj 74 194 s;
+#X obj 19 4 inlet bang;
+#X obj 77 23 r \$1-\$2;
+#X msg 51 80 begin \$1;
+#X msg 19 134 end \$1;
+#X obj 35 42 outlet;
+#X obj 19 23 t b s b s;
+#X obj 19 115 symbol \$2;
+#X connect 0 0 4 0;
+#X connect 2 0 7 0;
+#X connect 3 0 7 0;
+#X connect 4 0 1 0;
+#X connect 5 0 1 0;
+#X connect 7 0 8 0;
+#X connect 7 1 6 0;
+#X connect 7 2 0 0;
+#X connect 7 3 1 1;
+#X connect 8 0 5 0;
diff --git a/desiredata/extra/pureunity/trichotomy-test.pd b/desiredata/extra/pureunity/trichotomy-test.pd
new file mode 100644
index 00000000..49aa8e76
--- /dev/null
+++ b/desiredata/extra/pureunity/trichotomy-test.pd
@@ -0,0 +1,32 @@
+#N canvas 174 185 553 302 10;
+#X obj 13 21 inlet;
+#X obj 13 255 outlet;
+#X msg 13 40 1 2 \, 2 2 \, 2 1;
+#X msg 38 78 \$2 \$1;
+#X obj 13 117 +;
+#X obj 13 59 t a a a;
+#X obj 13 97 \$3;
+#X obj 38 97 \$3;
+#X obj 91 100 \$2;
+#X obj 38 117 +;
+#X obj 13 136 - 1;
+#X obj 13 155 t a a;
+#X obj 13 174 == 0;
+#X obj 13 236 list append trichotomy \$1 \$2;
+#X obj 13 217 pack 0 0 -1;
+#X connect 0 0 2 0;
+#X connect 2 0 5 0;
+#X connect 3 0 7 0;
+#X connect 4 0 10 0;
+#X connect 5 0 6 0;
+#X connect 5 1 3 0;
+#X connect 5 2 8 0;
+#X connect 6 0 4 0;
+#X connect 7 0 9 0;
+#X connect 8 0 9 1;
+#X connect 9 0 4 1;
+#X connect 11 0 12 0;
+#X connect 11 1 14 1;
+#X connect 12 0 14 0;
+#X connect 13 0 1 0;
+#X connect 14 0 13 0;
diff --git a/desiredata/extra/rev1-final.pd b/desiredata/extra/rev1-final.pd
new file mode 100644
index 00000000..0ed091c4
--- /dev/null
+++ b/desiredata/extra/rev1-final.pd
@@ -0,0 +1,106 @@
+#N canvas 133 53 729 468 10;
+#X obj 72 240 inlet~;
+#X obj 347 28 loadbang;
+#X obj 90 376 +~;
+#X obj 52 408 +~;
+#X obj 52 437 outlet~;
+#X obj 409 96 pow;
+#X obj 372 118 *;
+#X floatatom 372 159;
+#X obj 82 264 *~ 0;
+#X obj 177 175 pow;
+#X text 386 140 delay \, msec;
+#X floatatom 201 237;
+#X obj 190 150 * 0.001;
+#X text 206 220 gain for this stage;
+#X obj 103 327 *~ 0;
+#X obj 201 202 *;
+#X text 25 13 Allpass filter for mono reverberator. Arg 1 = delay name \, arg2 = stage number \, arg 3 = delay time;
+#X obj 373 76 8;
+#X obj 409 75 1.79;
+#X obj 114 175 0.7;
+#X obj 363 50 t b b b b;
+#X obj 177 108 0;
+#X obj 372 207 abs;
+#X obj 372 229 moses 0.01;
+#X obj 443 229 print wrong-delay-time;
+#X obj 233 391 inlet~;
+#X obj 219 419 +~;
+#X obj 219 443 outlet~;
+#X text 74 83 decay after;
+#X text 85 98 1 second;
+#X obj 83 119 r \$1-decay;
+#X obj 327 262 r \$1-clear;
+#X obj 240 298 0;
+#X obj 327 281 t b;
+#X obj 327 344 delay;
+#X obj 327 322 + 5;
+#X obj 158 279 delread~ \$2 \$4;
+#X obj 90 397 delwrite~ \$2 \$4;
+#X obj 327 302 f \$4;
+#X obj 371 184 - \$4;
+#X obj 446 75 float \$3;
+#X obj 241 318 1;
+#X obj 158 300 *~ 1;
+#X obj 52 298 *~ 0;
+#X obj 10 209 t b f f;
+#X obj 28 233 *;
+#X obj 10 256 -;
+#X obj 41 258 * -1;
+#X obj 11 297 *~ 0;
+#X obj 214 181 sqrt;
+#X connect 0 0 8 0;
+#X connect 1 0 20 0;
+#X connect 2 0 37 0;
+#X connect 3 0 4 0;
+#X connect 3 0 26 0;
+#X connect 5 0 6 1;
+#X connect 6 0 7 0;
+#X connect 6 0 12 0;
+#X connect 7 0 39 0;
+#X connect 8 0 43 0;
+#X connect 8 0 48 0;
+#X connect 9 0 15 0;
+#X connect 9 0 14 1;
+#X connect 12 0 9 1;
+#X connect 14 0 2 1;
+#X connect 14 0 3 1;
+#X connect 15 0 11 0;
+#X connect 15 0 8 1;
+#X connect 17 0 6 0;
+#X connect 18 0 5 0;
+#X connect 18 0 49 0;
+#X connect 19 0 44 0;
+#X connect 19 0 47 0;
+#X connect 20 0 21 0;
+#X connect 20 0 19 0;
+#X connect 20 1 17 0;
+#X connect 20 2 18 0;
+#X connect 20 3 40 0;
+#X connect 21 0 9 0;
+#X connect 22 0 23 0;
+#X connect 23 1 24 0;
+#X connect 25 0 26 1;
+#X connect 26 0 27 0;
+#X connect 30 0 9 0;
+#X connect 31 0 33 0;
+#X connect 32 0 42 1;
+#X connect 33 0 32 0;
+#X connect 33 0 38 0;
+#X connect 34 0 41 0;
+#X connect 35 0 34 0;
+#X connect 36 0 42 0;
+#X connect 38 0 35 0;
+#X connect 39 0 22 0;
+#X connect 40 0 5 1;
+#X connect 41 0 42 1;
+#X connect 42 0 14 0;
+#X connect 43 0 3 0;
+#X connect 44 0 46 0;
+#X connect 44 1 45 0;
+#X connect 44 2 45 1;
+#X connect 45 0 46 1;
+#X connect 46 0 48 1;
+#X connect 47 0 43 1;
+#X connect 48 0 2 0;
+#X connect 49 0 15 1;
diff --git a/desiredata/extra/rev1-stage.pd b/desiredata/extra/rev1-stage.pd
new file mode 100644
index 00000000..c1ee6574
--- /dev/null
+++ b/desiredata/extra/rev1-stage.pd
@@ -0,0 +1,99 @@
+#N canvas 86 133 729 452 10;
+#X obj 27 238 inlet~;
+#X obj 347 28 loadbang;
+#X obj 171 281 * -1;
+#X obj 36 353 +~;
+#X obj 69 395 +~;
+#X obj 69 424 outlet~;
+#X obj 409 96 pow;
+#X obj 372 118 *;
+#X floatatom 372 159;
+#X obj 37 262 *~ 0;
+#X obj 177 175 pow;
+#X text 408 162 delay \, msec;
+#X floatatom 177 238;
+#X obj 190 150 * 0.001;
+#X text 182 221 gain for this stage;
+#X obj 49 332 *~ 0;
+#X obj 47 375 *~ 0;
+#X obj 177 203 *;
+#X floatatom 409 119;
+#X text 25 13 Allpass filter for mono reverberator. Arg 1 = delay name \, arg2 = stage number \, arg 3 = delay time;
+#X obj 373 76 8;
+#X obj 409 75 1.79;
+#X obj 68 185 0.7;
+#X obj 363 50 t b b b b;
+#X obj 177 108 0;
+#X obj 372 207 abs;
+#X obj 372 229 moses 0.01;
+#X obj 443 229 print wrong-delay-time;
+#X obj 233 391 inlet~;
+#X obj 219 419 +~;
+#X obj 219 443 outlet~;
+#X text 74 83 decay after;
+#X text 85 98 1 second;
+#X obj 83 119 r \$1-decay;
+#X obj 259 256 r \$1-clear;
+#X obj 206 301 0;
+#X obj 259 275 t b;
+#X obj 259 338 delay;
+#X obj 259 316 + 5;
+#X obj 79 280 delread~ \$2 \$4;
+#X obj 36 447 delwrite~ \$2 \$4;
+#X obj 259 296 f \$4;
+#X obj 371 184 - \$4;
+#X obj 446 75 float \$3;
+#X obj 207 321 1;
+#X obj 79 301 *~ 1;
+#X obj 207 188 sqrt;
+#X floatatom 35 148;
+#X connect 0 0 9 0;
+#X connect 1 0 23 0;
+#X connect 2 0 16 1;
+#X connect 3 0 16 0;
+#X connect 3 0 40 0;
+#X connect 4 0 5 0;
+#X connect 4 0 29 0;
+#X connect 6 0 7 1;
+#X connect 6 0 18 0;
+#X connect 7 0 8 0;
+#X connect 7 0 13 0;
+#X connect 8 0 42 0;
+#X connect 9 0 3 0;
+#X connect 10 0 17 0;
+#X connect 13 0 10 1;
+#X connect 15 0 3 1;
+#X connect 16 0 4 0;
+#X connect 17 0 12 0;
+#X connect 17 0 9 1;
+#X connect 20 0 7 0;
+#X connect 21 0 6 0;
+#X connect 21 0 46 0;
+#X connect 22 0 2 0;
+#X connect 22 0 15 1;
+#X connect 23 0 24 0;
+#X connect 23 0 22 0;
+#X connect 23 1 20 0;
+#X connect 23 2 21 0;
+#X connect 23 3 43 0;
+#X connect 24 0 10 0;
+#X connect 25 0 26 0;
+#X connect 26 1 27 0;
+#X connect 28 0 29 1;
+#X connect 29 0 30 0;
+#X connect 33 0 10 0;
+#X connect 33 0 47 0;
+#X connect 34 0 36 0;
+#X connect 35 0 45 1;
+#X connect 36 0 35 0;
+#X connect 36 0 41 0;
+#X connect 37 0 44 0;
+#X connect 38 0 37 0;
+#X connect 39 0 45 0;
+#X connect 41 0 38 0;
+#X connect 42 0 25 0;
+#X connect 43 0 6 1;
+#X connect 44 0 45 1;
+#X connect 45 0 15 0;
+#X connect 45 0 4 1;
+#X connect 46 0 17 1;
diff --git a/desiredata/extra/rev1~.pd b/desiredata/extra/rev1~.pd
new file mode 100644
index 00000000..83fd6d20
--- /dev/null
+++ b/desiredata/extra/rev1~.pd
@@ -0,0 +1,64 @@
+#N canvas 66 116 512 312 10;
+#X obj 345 154 dbtorms;
+#X obj 316 120 min 100;
+#X obj 316 100 inlet;
+#X obj 45 16 inlet~;
+#X obj 254 298 outlet~;
+#X obj 432 106 inlet;
+#X obj 432 130 t b;
+#X obj 269 145 t b f;
+#X obj 281 185 -;
+#X obj 282 254 line~;
+#X obj 282 233 pack 0 100;
+#X obj 269 166 105;
+#X obj 256 276 *~;
+#X obj 282 210 * 0.01;
+#X text 282 65 reverb decay speed;
+#X text 278 79 (dB left after 1 sec);
+#X text 425 84 bang to clear;
+#X obj 44 41 rev1-stage \$0 \$0-del1 0 8;
+#X obj 44 64 rev1-stage \$0 \$0-del2 1 14.32;
+#X obj 44 87 rev1-stage \$0 \$0-del3 2 25.6328;
+#X obj 44 110 rev1-stage \$0 \$0-del4 3 45.8827;
+#X obj 44 133 rev1-stage \$0 \$0-del5 4 82.1301;
+#X obj 44 156 rev1-stage \$0 \$0-del6 5 147.013;
+#X obj 44 179 rev1-stage \$0 \$0-del7 6 263.153;
+#X obj 44 202 rev1-stage \$0 \$0-del8 7 471.044;
+#X obj 44 225 rev1-stage \$0 \$0-del9 8 843.168;
+#X obj 44 248 rev1-final \$0 \$0-del10 9 1509.27;
+#X obj 346 177 s \$0-decay;
+#X obj 432 153 s \$0-clear;
+#X connect 0 0 27 0;
+#X connect 1 0 0 0;
+#X connect 1 0 7 0;
+#X connect 2 0 1 0;
+#X connect 3 0 17 0;
+#X connect 5 0 6 0;
+#X connect 6 0 28 0;
+#X connect 7 0 11 0;
+#X connect 7 1 8 1;
+#X connect 8 0 13 0;
+#X connect 9 0 12 1;
+#X connect 10 0 9 0;
+#X connect 11 0 8 0;
+#X connect 12 0 4 0;
+#X connect 13 0 10 0;
+#X connect 17 0 18 0;
+#X connect 17 1 18 1;
+#X connect 18 0 19 0;
+#X connect 18 1 19 1;
+#X connect 19 0 20 0;
+#X connect 19 1 20 1;
+#X connect 20 0 21 0;
+#X connect 20 1 21 1;
+#X connect 21 0 22 0;
+#X connect 21 1 22 1;
+#X connect 22 0 23 0;
+#X connect 22 1 23 1;
+#X connect 23 0 24 0;
+#X connect 23 1 24 1;
+#X connect 24 0 25 0;
+#X connect 24 1 25 1;
+#X connect 25 0 26 0;
+#X connect 25 1 26 1;
+#X connect 26 1 12 0;
diff --git a/desiredata/extra/rev2~.pd b/desiredata/extra/rev2~.pd
new file mode 100644
index 00000000..5b87faa7
--- /dev/null
+++ b/desiredata/extra/rev2~.pd
@@ -0,0 +1,237 @@
+#N canvas 333 147 832 664 12;
+#X obj 161 497 +~;
+#X obj 520 105 inlet;
+#X obj 184 407 *~;
+#X obj 486 412 *~;
+#X obj 285 412 *~;
+#X obj 387 412 *~;
+#X obj 443 546 -~;
+#X obj 364 545 -~;
+#X obj 239 537 +~;
+#X obj 161 534 +~;
+#X obj 162 444 +~;
+#X obj 262 440 +~;
+#X obj 464 501 -~;
+#X obj 387 499 +~;
+#X obj 239 500 -~;
+#X obj 452 105 inlet;
+#X obj 609 429 line~;
+#X obj 509 374 line~;
+#X obj 16 121 delread~ \$0-del1 58.6435;
+#X obj 94 143 delread~ \$0-del2 69.4325;
+#X obj 176 165 delread~ \$0-del3 74.5234;
+#X obj 258 189 delread~ \$0-del4 86.1244;
+#X obj 530 500 *~;
+#X obj 599 501 *~;
+#X obj 161 641 delwrite~ \$0-del1 58.6435;
+#X obj 240 617 delwrite~ \$0-del2 69.4325;
+#X obj 365 595 delwrite~ \$0-del3 74.5234;
+#X obj 444 573 delwrite~ \$0-del4 86.1244;
+#X obj 609 357 dbtorms;
+#X obj 609 403 pack 0 30;
+#X obj 520 211 pack 0 50;
+#X obj 9 390 inlet~;
+#X obj 530 525 outlet~;
+#X obj 599 525 outlet~;
+#X obj 520 187 / 200;
+#X obj 520 162 clip 0 100;
+#X obj 52 236 lop~;
+#X obj 452 137 f \$1;
+#X obj 520 138 f \$2;
+#X obj 625 143 f \$3;
+#X obj 696 143 f \$4;
+#X obj 367 106 loadbang;
+#X obj 667 500 *~;
+#X obj 735 501 *~;
+#X obj 667 525 outlet~;
+#X obj 735 525 outlet~;
+#X obj 625 167 moses 1;
+#X msg 631 193 3000;
+#X obj 705 193 clip 0 100;
+#N canvas 345 88 355 597 early-reflect 0;
+#X obj 119 477 delread~ \$0-ref6 13.645;
+#X obj 119 453 delwrite~ \$0-ref6 13.645;
+#X obj 106 400 delread~ \$0-ref5 16.364;
+#X obj 106 376 delwrite~ \$0-ref5 16.364;
+#X obj 102 324 delread~ \$0-ref4 19.392;
+#X obj 102 300 delwrite~ \$0-ref4 19.392;
+#X obj 106 247 delread~ \$0-ref3 25.796;
+#X obj 106 223 delwrite~ \$0-ref3 25.796;
+#X obj 107 169 delread~ \$0-ref2 43.5337;
+#X obj 107 145 delwrite~ \$0-ref2 43.5337;
+#X obj 110 90 delread~ \$0-ref1 75.2546;
+#X obj 84 119 -~;
+#X obj 49 119 +~;
+#X obj 50 195 +~;
+#X obj 85 196 -~;
+#X obj 84 275 -~;
+#X obj 49 274 +~;
+#X obj 82 349 -~;
+#X obj 48 350 +~;
+#X obj 83 428 -~;
+#X obj 49 428 +~;
+#X obj 65 7 inlet~;
+#X obj 110 66 delwrite~ \$0-ref1 75.2546;
+#X obj 49 508 outlet~;
+#X obj 119 507 outlet~;
+#X connect 0 0 24 0;
+#X connect 2 0 20 1;
+#X connect 2 0 19 1;
+#X connect 4 0 18 1;
+#X connect 4 0 17 1;
+#X connect 6 0 16 1;
+#X connect 6 0 15 1;
+#X connect 8 0 13 1;
+#X connect 8 0 14 1;
+#X connect 10 0 12 1;
+#X connect 10 0 11 1;
+#X connect 11 0 9 0;
+#X connect 12 0 14 0;
+#X connect 12 0 13 0;
+#X connect 13 0 16 0;
+#X connect 13 0 15 0;
+#X connect 14 0 7 0;
+#X connect 15 0 5 0;
+#X connect 16 0 18 0;
+#X connect 16 0 17 0;
+#X connect 17 0 3 0;
+#X connect 18 0 20 0;
+#X connect 18 0 19 0;
+#X connect 19 0 1 0;
+#X connect 20 0 23 0;
+#X connect 21 0 12 0;
+#X connect 21 0 11 0;
+#X connect 21 0 22 0;
+#X restore 9 416 pd early-reflect;
+#X obj 618 216 f;
+#X obj 618 105 inlet;
+#X obj 696 109 inlet;
+#X obj 705 216 f;
+#X obj 705 239 * 0.01;
+#X obj 705 263 pack 0 50;
+#X obj 705 287 line~;
+#X obj 29 269 -~;
+#X obj 28 300 *~;
+#X obj 16 331 +~;
+#X obj 132 240 lop~;
+#X obj 106 274 -~;
+#X obj 105 309 *~;
+#X obj 95 333 +~;
+#X obj 214 245 lop~;
+#X obj 188 273 -~;
+#X obj 187 314 *~;
+#X obj 176 339 +~;
+#X obj 308 249 lop~;
+#X obj 281 274 -~;
+#X obj 281 318 *~;
+#X obj 258 342 +~;
+#X obj 609 379 * 0.125;
+#X text 403 10 control inlets:;
+#X text 9 9 rev2 - simple \, cheap reverberator with;
+#X text 400 29 1: output level \, dB \, 0-100;
+#X text 8 30 one signal inlet and four signal outlets.;
+#X text 399 79 4: high frequency damping \, 0-100;
+#X text 400 62 3: crossover frequency in Hz. (3000 default);
+#X text 400 45 2: liveness \, 0-100 \, usually between 85 and 100;
+#X connect 0 0 9 0;
+#X connect 0 0 7 0;
+#X connect 1 0 38 0;
+#X connect 2 0 10 1;
+#X connect 3 0 12 1;
+#X connect 3 0 13 1;
+#X connect 3 0 43 0;
+#X connect 4 0 11 1;
+#X connect 5 0 13 0;
+#X connect 5 0 12 0;
+#X connect 5 0 42 0;
+#X connect 6 0 27 0;
+#X connect 7 0 26 0;
+#X connect 8 0 25 0;
+#X connect 9 0 24 0;
+#X connect 10 0 14 0;
+#X connect 10 0 0 0;
+#X connect 10 0 22 0;
+#X connect 11 0 0 1;
+#X connect 11 0 14 1;
+#X connect 11 0 23 0;
+#X connect 12 0 8 1;
+#X connect 12 0 6 1;
+#X connect 13 0 9 1;
+#X connect 13 0 7 1;
+#X connect 14 0 8 0;
+#X connect 14 0 6 0;
+#X connect 15 0 37 0;
+#X connect 16 0 22 1;
+#X connect 16 0 23 1;
+#X connect 16 0 42 1;
+#X connect 16 0 43 1;
+#X connect 17 0 4 1;
+#X connect 17 0 2 1;
+#X connect 17 0 5 1;
+#X connect 17 0 3 1;
+#X connect 18 0 36 0;
+#X connect 18 0 57 1;
+#X connect 18 0 59 0;
+#X connect 19 0 60 0;
+#X connect 19 0 61 1;
+#X connect 19 0 63 0;
+#X connect 20 0 67 0;
+#X connect 20 0 64 0;
+#X connect 20 0 65 1;
+#X connect 21 0 71 0;
+#X connect 21 0 69 1;
+#X connect 21 0 68 0;
+#X connect 22 0 32 0;
+#X connect 23 0 33 0;
+#X connect 28 0 72 0;
+#X connect 29 0 16 0;
+#X connect 30 0 17 0;
+#X connect 31 0 49 0;
+#X connect 34 0 30 0;
+#X connect 35 0 34 0;
+#X connect 36 0 57 0;
+#X connect 37 0 28 0;
+#X connect 38 0 35 0;
+#X connect 39 0 46 0;
+#X connect 40 0 48 0;
+#X connect 41 0 37 0;
+#X connect 41 0 38 0;
+#X connect 41 0 39 0;
+#X connect 41 0 40 0;
+#X connect 42 0 44 0;
+#X connect 43 0 45 0;
+#X connect 46 0 47 0;
+#X connect 46 1 50 0;
+#X connect 47 0 50 0;
+#X connect 48 0 53 0;
+#X connect 49 0 10 0;
+#X connect 49 1 11 0;
+#X connect 50 0 36 1;
+#X connect 50 0 60 1;
+#X connect 50 0 64 1;
+#X connect 50 0 68 1;
+#X connect 51 0 50 0;
+#X connect 52 0 40 0;
+#X connect 53 0 54 0;
+#X connect 54 0 55 0;
+#X connect 55 0 56 0;
+#X connect 56 0 58 1;
+#X connect 56 0 62 1;
+#X connect 56 0 66 1;
+#X connect 56 0 70 1;
+#X connect 57 0 58 0;
+#X connect 58 0 59 1;
+#X connect 59 0 2 0;
+#X connect 60 0 61 0;
+#X connect 61 0 62 0;
+#X connect 62 0 63 1;
+#X connect 63 0 4 0;
+#X connect 64 0 65 0;
+#X connect 65 0 66 0;
+#X connect 66 0 67 1;
+#X connect 67 0 5 0;
+#X connect 68 0 69 0;
+#X connect 69 0 70 0;
+#X connect 70 0 71 1;
+#X connect 71 0 3 0;
+#X connect 72 0 29 0;
diff --git a/desiredata/extra/rev3~.pd b/desiredata/extra/rev3~.pd
new file mode 100644
index 00000000..0d8ea472
--- /dev/null
+++ b/desiredata/extra/rev3~.pd
@@ -0,0 +1,439 @@
+#N canvas 220 79 810 570 12;
+#X obj 520 105 inlet;
+#X obj 452 105 inlet;
+#X obj 370 335 line~;
+#X obj 232 394 *~;
+#X obj 301 395 *~;
+#X obj 370 284 dbtorms;
+#X obj 370 309 pack 0 30;
+#X obj 520 211 pack 0 50;
+#X obj 232 419 outlet~;
+#X obj 301 419 outlet~;
+#X obj 520 162 clip 0 100;
+#X obj 452 137 f \$1;
+#X obj 520 138 f \$2;
+#X obj 625 143 f \$3;
+#X obj 696 143 f \$4;
+#X obj 367 106 loadbang;
+#X obj 369 394 *~;
+#X obj 437 395 *~;
+#X obj 369 419 outlet~;
+#X obj 437 419 outlet~;
+#X obj 625 167 moses 1;
+#X msg 631 193 3000;
+#X obj 705 193 clip 0 100;
+#X obj 616 218 f;
+#X obj 618 105 inlet;
+#X obj 696 109 inlet;
+#X obj 705 216 f;
+#X obj 705 239 * 0.01;
+#X obj 705 263 pack 0 50;
+#X text 403 10 control inlets:;
+#X text 400 29 1: output level \, dB \, 0-100;
+#X text 399 79 4: high frequency damping \, 0-100;
+#X text 400 62 3: crossover frequency in Hz. (3000 default);
+#X text 400 45 2: liveness \, 0-100 \, usually between 85 and 100;
+#X obj 616 242 s \$0-lop;
+#N canvas 169 94 919 805 doit 0;
+#X obj 218 386 *~;
+#X obj 341 396 *~;
+#X obj 267 389 *~;
+#X obj 305 392 *~;
+#X obj 28 175 lop~;
+#X obj 27 204 -~;
+#X obj 27 291 *~;
+#X obj 16 319 +~;
+#X obj 75 182 lop~;
+#X obj 76 214 -~;
+#X obj 77 294 *~;
+#X obj 67 318 +~;
+#X obj 124 187 lop~;
+#X obj 124 214 -~;
+#X obj 125 297 *~;
+#X obj 116 322 +~;
+#X obj 176 191 lop~;
+#X obj 175 218 -~;
+#X obj 175 301 *~;
+#X obj 168 326 +~;
+#X obj 15 372 *~;
+#X obj 169 383 *~;
+#X obj 67 376 *~;
+#X obj 115 380 *~;
+#X obj 207 160 r \$0-lop;
+#X obj 183 246 r \$0-damp;
+#X obj 183 271 line~;
+#X obj 17 14 delread~ \$0-del1 10;
+#X obj 117 56 delread~ \$0-del3 13.4567;
+#X obj 68 35 delread~ \$0-del2 11.6356;
+#X obj 171 77 delread~ \$0-del4 16.7345;
+#X obj 524 407 *~;
+#X obj 631 409 *~;
+#X obj 560 408 *~;
+#X obj 595 409 *~;
+#X obj 377 399 *~;
+#X obj 488 406 *~;
+#X obj 414 402 *~;
+#X obj 451 405 *~;
+#X obj 654 354 line~;
+#X obj 708 387 r \$0-fb;
+#X obj 218 100 delread~ \$0-del5 20.1862;
+#X obj 267 121 delread~ \$0-del6 25.7417;
+#X obj 304 142 delread~ \$0-del7 31.4693;
+#X obj 341 163 delread~ \$0-del8 38.2944;
+#X obj 376 184 delread~ \$0-del9 46.6838;
+#X obj 414 205 delread~ \$0-del10 55.4567;
+#X obj 488 247 delread~ \$0-del12 76.8243;
+#X obj 524 268 delread~ \$0-del13 88.5623;
+#X obj 561 289 delread~ \$0-del14 101.278;
+#X obj 595 310 delread~ \$0-del15 115.397;
+#X obj 632 331 delread~ \$0-del16 130.502;
+#X obj 25 346 inlet~;
+#X obj 87 346 inlet~;
+#X obj 69 440 +~;
+#X obj 105 440 -~;
+#X obj 141 440 +~;
+#X obj 177 440 -~;
+#X obj 214 440 +~;
+#X obj 250 440 -~;
+#X obj 286 440 +~;
+#X obj 322 440 -~;
+#X obj 359 440 +~;
+#X obj 395 440 -~;
+#X obj 431 440 +~;
+#X obj 467 440 -~;
+#X obj 504 440 +~;
+#X obj 540 440 -~;
+#X obj 576 440 +~;
+#X obj 612 440 -~;
+#X obj 69 474 +~;
+#X obj 177 474 -~;
+#X obj 105 474 +~;
+#X obj 141 474 -~;
+#X obj 214 474 +~;
+#X obj 322 474 -~;
+#X obj 250 474 +~;
+#X obj 286 474 -~;
+#X obj 359 474 +~;
+#X obj 467 474 -~;
+#X obj 395 474 +~;
+#X obj 431 474 -~;
+#X obj 504 474 +~;
+#X obj 612 474 -~;
+#X obj 540 474 +~;
+#X obj 576 474 -~;
+#X obj 69 518 +~;
+#X obj 105 518 +~;
+#X obj 322 518 -~;
+#X obj 286 518 -~;
+#X obj 141 518 +~;
+#X obj 177 518 +~;
+#X obj 214 518 -~;
+#X obj 250 518 -~;
+#X obj 360 518 +~;
+#X obj 396 518 +~;
+#X obj 613 518 -~;
+#X obj 577 518 -~;
+#X obj 432 518 +~;
+#X obj 468 518 +~;
+#X obj 505 518 -~;
+#X obj 541 518 -~;
+#X obj 70 575 +~;
+#X obj 106 575 +~;
+#X obj 469 575 -~;
+#X obj 433 575 -~;
+#X obj 142 575 +~;
+#X obj 178 575 +~;
+#X obj 361 575 -~;
+#X obj 397 575 -~;
+#X obj 215 575 +~;
+#X obj 251 575 +~;
+#X obj 287 575 +~;
+#X obj 323 575 +~;
+#X obj 614 575 -~;
+#X obj 578 575 -~;
+#X obj 506 575 -~;
+#X obj 542 575 -~;
+#X obj 628 606 outlet~;
+#X obj 698 606 outlet~;
+#X obj 768 607 outlet~;
+#X obj 838 607 outlet~;
+#X obj 451 226 delread~ \$0-del11 65.1755;
+#X obj 614 629 delwrite~ \$0-del16 130.502;
+#X obj 361 776 delwrite~ \$0-del9 46.6838;
+#X obj 398 755 delwrite~ \$0-del10 55.4567;
+#X obj 434 734 delwrite~ \$0-del11 65.1755;
+#X obj 470 713 delwrite~ \$0-del12 76.8243;
+#X obj 506 692 delwrite~ \$0-del13 88.5623;
+#X obj 542 671 delwrite~ \$0-del14 101.278;
+#X obj 579 650 delwrite~ \$0-del15 115.397;
+#X obj 323 606 delwrite~ \$0-del8 38.2944;
+#X obj 287 628 delwrite~ \$0-del7 31.4693;
+#X obj 252 650 delwrite~ \$0-del6 25.7417;
+#X obj 215 672 delwrite~ \$0-del5 20.1862;
+#X obj 71 761 delwrite~ \$0-del1 10;
+#X obj 106 737 delwrite~ \$0-del2 11.6356;
+#X obj 141 715 delwrite~ \$0-del3 13.4567;
+#X obj 179 693 delwrite~ \$0-del4 16.7345;
+#X connect 0 0 58 0;
+#X connect 0 0 59 0;
+#X connect 1 0 60 1;
+#X connect 1 0 61 1;
+#X connect 2 0 58 1;
+#X connect 2 0 59 1;
+#X connect 3 0 60 0;
+#X connect 3 0 61 0;
+#X connect 4 0 5 0;
+#X connect 5 0 6 0;
+#X connect 6 0 7 1;
+#X connect 7 0 20 0;
+#X connect 8 0 9 0;
+#X connect 9 0 10 0;
+#X connect 10 0 11 1;
+#X connect 11 0 22 0;
+#X connect 12 0 13 0;
+#X connect 13 0 14 0;
+#X connect 14 0 15 1;
+#X connect 15 0 23 0;
+#X connect 16 0 17 0;
+#X connect 17 0 18 0;
+#X connect 18 0 19 1;
+#X connect 19 0 21 0;
+#X connect 20 0 54 0;
+#X connect 20 0 55 0;
+#X connect 21 0 56 1;
+#X connect 21 0 57 1;
+#X connect 22 0 55 1;
+#X connect 22 0 54 1;
+#X connect 23 0 56 0;
+#X connect 23 0 57 0;
+#X connect 24 0 16 1;
+#X connect 24 0 12 1;
+#X connect 24 0 8 1;
+#X connect 24 0 4 1;
+#X connect 25 0 26 0;
+#X connect 26 0 18 1;
+#X connect 26 0 14 1;
+#X connect 26 0 10 1;
+#X connect 26 0 6 1;
+#X connect 27 0 4 0;
+#X connect 27 0 5 1;
+#X connect 27 0 7 0;
+#X connect 28 0 15 0;
+#X connect 28 0 12 0;
+#X connect 28 0 13 1;
+#X connect 29 0 8 0;
+#X connect 29 0 9 1;
+#X connect 29 0 11 0;
+#X connect 30 0 19 0;
+#X connect 30 0 17 1;
+#X connect 30 0 16 0;
+#X connect 31 0 66 0;
+#X connect 31 0 67 0;
+#X connect 32 0 68 1;
+#X connect 32 0 69 1;
+#X connect 33 0 66 1;
+#X connect 33 0 67 1;
+#X connect 34 0 68 0;
+#X connect 34 0 69 0;
+#X connect 35 0 62 0;
+#X connect 35 0 63 0;
+#X connect 36 0 64 1;
+#X connect 36 0 65 1;
+#X connect 37 0 62 1;
+#X connect 37 0 63 1;
+#X connect 38 0 64 0;
+#X connect 38 0 65 0;
+#X connect 39 0 2 1;
+#X connect 39 0 0 1;
+#X connect 39 0 3 1;
+#X connect 39 0 1 1;
+#X connect 39 0 21 1;
+#X connect 39 0 23 1;
+#X connect 39 0 22 1;
+#X connect 39 0 20 1;
+#X connect 39 0 35 1;
+#X connect 39 0 38 1;
+#X connect 39 0 36 1;
+#X connect 39 0 31 1;
+#X connect 39 0 33 1;
+#X connect 39 0 34 1;
+#X connect 39 0 32 1;
+#X connect 39 0 37 1;
+#X connect 40 0 39 0;
+#X connect 41 0 0 0;
+#X connect 42 0 2 0;
+#X connect 43 0 3 0;
+#X connect 44 0 1 0;
+#X connect 45 0 35 0;
+#X connect 46 0 37 0;
+#X connect 47 0 36 0;
+#X connect 48 0 31 0;
+#X connect 49 0 33 0;
+#X connect 50 0 34 0;
+#X connect 51 0 32 0;
+#X connect 52 0 20 0;
+#X connect 53 0 22 0;
+#X connect 54 0 70 0;
+#X connect 54 0 73 0;
+#X connect 55 0 72 0;
+#X connect 55 0 71 0;
+#X connect 56 0 70 1;
+#X connect 56 0 73 1;
+#X connect 57 0 72 1;
+#X connect 57 0 71 1;
+#X connect 58 0 74 0;
+#X connect 58 0 77 0;
+#X connect 59 0 76 0;
+#X connect 59 0 75 0;
+#X connect 60 0 74 1;
+#X connect 60 0 77 1;
+#X connect 61 0 76 1;
+#X connect 61 0 75 1;
+#X connect 62 0 78 0;
+#X connect 62 0 81 0;
+#X connect 63 0 80 0;
+#X connect 63 0 79 0;
+#X connect 64 0 78 1;
+#X connect 64 0 81 1;
+#X connect 65 0 80 1;
+#X connect 65 0 79 1;
+#X connect 66 0 82 0;
+#X connect 66 0 85 0;
+#X connect 67 0 84 0;
+#X connect 67 0 83 0;
+#X connect 68 0 82 1;
+#X connect 68 0 85 1;
+#X connect 69 0 84 1;
+#X connect 69 0 83 1;
+#X connect 70 0 86 0;
+#X connect 70 0 92 0;
+#X connect 71 0 91 0;
+#X connect 71 0 88 0;
+#X connect 72 0 87 0;
+#X connect 72 0 93 0;
+#X connect 73 0 90 0;
+#X connect 73 0 89 0;
+#X connect 74 0 86 1;
+#X connect 74 0 92 1;
+#X connect 75 0 91 1;
+#X connect 75 0 88 1;
+#X connect 76 0 87 1;
+#X connect 76 0 93 1;
+#X connect 77 0 90 1;
+#X connect 77 0 89 1;
+#X connect 78 0 94 0;
+#X connect 78 0 100 0;
+#X connect 79 0 99 0;
+#X connect 79 0 96 0;
+#X connect 80 0 95 0;
+#X connect 80 0 101 0;
+#X connect 81 0 98 0;
+#X connect 81 0 97 0;
+#X connect 82 0 94 1;
+#X connect 82 0 100 1;
+#X connect 83 0 99 1;
+#X connect 83 0 96 1;
+#X connect 84 0 95 1;
+#X connect 84 0 101 1;
+#X connect 85 0 98 1;
+#X connect 85 0 97 1;
+#X connect 86 0 102 0;
+#X connect 86 0 108 0;
+#X connect 87 0 103 0;
+#X connect 87 0 109 0;
+#X connect 88 0 113 0;
+#X connect 88 0 114 0;
+#X connect 89 0 112 0;
+#X connect 89 0 115 0;
+#X connect 90 0 106 0;
+#X connect 90 0 105 0;
+#X connect 91 0 107 0;
+#X connect 91 0 104 0;
+#X connect 92 0 110 0;
+#X connect 92 0 116 0;
+#X connect 93 0 111 0;
+#X connect 93 0 117 0;
+#X connect 94 0 108 1;
+#X connect 94 0 102 1;
+#X connect 95 0 109 1;
+#X connect 95 0 103 1;
+#X connect 96 0 114 1;
+#X connect 96 0 113 1;
+#X connect 97 0 115 1;
+#X connect 97 0 112 1;
+#X connect 98 0 105 1;
+#X connect 98 0 106 1;
+#X connect 99 0 104 1;
+#X connect 99 0 107 1;
+#X connect 100 0 116 1;
+#X connect 100 0 110 1;
+#X connect 101 0 117 1;
+#X connect 101 0 111 1;
+#X connect 102 0 135 0;
+#X connect 103 0 136 0;
+#X connect 104 0 127 0;
+#X connect 105 0 126 0;
+#X connect 106 0 137 0;
+#X connect 107 0 138 0;
+#X connect 108 0 124 0;
+#X connect 109 0 125 0;
+#X connect 110 0 134 0;
+#X connect 111 0 133 0;
+#X connect 112 0 132 0;
+#X connect 113 0 131 0;
+#X connect 114 0 121 0;
+#X connect 114 0 123 0;
+#X connect 115 0 120 0;
+#X connect 115 0 130 0;
+#X connect 116 0 118 0;
+#X connect 116 0 128 0;
+#X connect 117 0 119 0;
+#X connect 117 0 129 0;
+#X connect 122 0 38 0;
+#X restore 164 317 pd doit;
+#X obj 165 255 inlet~;
+#X obj 222 255 inlet~;
+#X obj 520 241 s \$0-fb;
+#X obj 705 290 s \$0-damp;
+#X text 57 490 rev3 - 16-delay reverberator. Like rev2~ but presumably
+higher-quality and takes two audio inputs.;
+#X obj 520 187 / 400;
+#X connect 0 0 12 0;
+#X connect 1 0 11 0;
+#X connect 2 0 3 1;
+#X connect 2 0 4 1;
+#X connect 2 0 16 1;
+#X connect 2 0 17 1;
+#X connect 3 0 8 0;
+#X connect 4 0 9 0;
+#X connect 5 0 6 0;
+#X connect 6 0 2 0;
+#X connect 7 0 38 0;
+#X connect 10 0 41 0;
+#X connect 11 0 5 0;
+#X connect 12 0 10 0;
+#X connect 13 0 20 0;
+#X connect 14 0 22 0;
+#X connect 15 0 11 0;
+#X connect 15 0 12 0;
+#X connect 15 0 13 0;
+#X connect 15 0 14 0;
+#X connect 16 0 18 0;
+#X connect 17 0 19 0;
+#X connect 20 0 21 0;
+#X connect 20 1 23 0;
+#X connect 21 0 23 0;
+#X connect 22 0 26 0;
+#X connect 23 0 34 0;
+#X connect 24 0 23 0;
+#X connect 25 0 14 0;
+#X connect 26 0 27 0;
+#X connect 27 0 28 0;
+#X connect 28 0 39 0;
+#X connect 35 0 3 0;
+#X connect 35 1 4 0;
+#X connect 35 2 16 0;
+#X connect 35 3 17 0;
+#X connect 36 0 35 0;
+#X connect 37 0 35 1;
+#X connect 41 0 7 0;
diff --git a/desiredata/extra/sigmund~/makefile b/desiredata/extra/sigmund~/makefile
new file mode 100644
index 00000000..3dc176b3
--- /dev/null
+++ b/desiredata/extra/sigmund~/makefile
@@ -0,0 +1,4 @@
+NAME=sigmund~
+CSYM=sigmund_tilde
+
+include ../makefile
diff --git a/desiredata/extra/sigmund~/sigmund~-help.pd b/desiredata/extra/sigmund~/sigmund~-help.pd
new file mode 100644
index 00000000..f3556c9c
--- /dev/null
+++ b/desiredata/extra/sigmund~/sigmund~-help.pd
@@ -0,0 +1,172 @@
+#N canvas 209 199 580 617 12;
+#X text 42 4 sigmund~ - sinusoidal analysis and pitch tracking;
+#N canvas 432 117 573 597 using-with-tables 0;
+#X obj 29 368 print peak;
+#N canvas 0 0 450 300 (subpatch) 0;
+#X array insignal 1024 float 2;
+#X coords 0 1 1023 -1 200 140 1;
+#X restore 83 426 graph;
+#X obj 314 513 phasor~;
+#X obj 294 429 loadbang;
+#X obj 314 461 440;
+#X floatatom 313 488 5 0 0 0 - - -;
+#X obj 305 544 tabwrite~ insignal;
+#X obj 290 516 bng 15 250 50 0 empty empty empty 17 7 0 10 -262144
+-1 -1;
+#X text 114 11 Using sigmund~ on arrays;
+#X text 42 33 If invoked with the "-t" flag (as a creation argument)
+\, sigmund~ analyzes waveforms stored in arrays. Instead of an incoming
+signal \, feed it "list" messages with the following arguments:;
+#X text 37 118 table name (a symbol);
+#X text 38 137 number of points;
+#X obj 29 342 sigmund~ -t -npeak 10 -maxfreq 5000 peaks;
+#X msg 29 316 list insignal 1024 0 44100 0;
+#X text 37 158 index of first point;
+#X text 39 179 sample rate;
+#X text 38 200 debug flag (print debugging info if nonzero);
+#X text 23 232 In this mode \, only the "env" \, "pitch" \, and "peaks"
+outputs are meaningful.;
+#X text 31 294 click here to test:;
+#X connect 2 0 6 0;
+#X connect 3 0 4 0;
+#X connect 4 0 5 0;
+#X connect 5 0 2 0;
+#X connect 5 0 7 0;
+#X connect 7 0 6 0;
+#X connect 12 0 0 0;
+#X connect 13 0 12 0;
+#X restore 330 553 pd using-with-tables;
+#X obj 40 512 phasor~;
+#X obj 40 425 loadbang;
+#X floatatom 40 471 5 0 120 0 - - -;
+#X floatatom 39 561 5 0 0 0 - - -;
+#X floatatom 245 563 5 0 0 0 - - -;
+#X obj 40 490 mtof;
+#X obj 40 448 69;
+#X text 38 579 pitch;
+#X text 222 582 envelope;
+#X text 13 28 Sigmund~ analyzes an incoming sound into sinusoidal components
+\, which may be reported individually or combined to form a pitch estimate.
+Possible outputs are specified as creation arguments:;
+#X text 55 129 env - output pitches at the beginning of notes;
+#X text 56 95 pitch - output pitch continuously;
+#N canvas 518 74 588 728 setting-parameters 0;
+#X msg 182 66 print;
+#X floatatom 192 92 5 0 0 0 - - -;
+#X msg 192 113 minpower \$1;
+#X obj 182 139 sigmund~ -minpower 40;
+#X text 39 14 You can set parameters either by creation arguments \,
+or else using messages. The "print" message gives you the current values
+of all the parameters:;
+#X text 28 169 npts: number of points used in an analysis. Must be
+a power of two \, at least 128 The minimum frequency that can be tracked
+is about 2(sample_rate)/npts.;
+#X text 26 219 hop: number of points between analyses. Must be a power
+of two \, at least the DSP vector size (usually 64). This regulates
+the number of analyses done per unit of time.;
+#X text 28 271 npeak: maximum number of sinusoidal peaks to look for.
+The computation time is quadratic in the number of peaks actually found
+(this number only sets an upper limit). Use it to balance CPU time
+with quality of results.;
+#X text 30 336 maxfreq: maximum frequency of sinusoidal peaks to look
+for. This can be useful in situations where background noise creates
+high-frequency \, spurious peaks..;
+#X text 37 388 vibrato: maximum deviation from "pitch" to accept as
+normal vibrato (affects "notes" output only). If the value is too small.
+vibratos will appear as trills. If too large \, very small melodic
+intervals may not be reported as new notes.;
+#X text 33 457 stabletime: time period to wait before reporting a note
+(affects "notes" output only). The "pitch" must be present and must
+not vary more than "vibrato" for this entire period to report a note.
+If too large \, the "notes" will be unnecessarily delayed. If too small
+\, spurious notes get output.;
+#X text 31 551 minpower: minimum measured RMS level to report a pitch
+(affects "pitch" and "notes" output only). Signals quieter than this
+will be assumed to be crosstalk and ignored.;
+#X text 32 602 growth: minimum measured RMS growth to report a new
+note (affects "notes" output only). The RMS level must rise by this
+many dB (within a time period given by "stabletime") to report a repetition
+of a note at or near the previously output pitch.;
+#X connect 0 0 3 0;
+#X connect 1 0 2 0;
+#X connect 2 0 3 0;
+#X restore 330 531 pd setting-parameters;
+#N canvas 190 230 640 535 sinusoid-tracking 0;
+#X obj 124 267 sigmund~ -npeak 10 peaks;
+#X obj 124 214 phasor~;
+#X obj 124 144 loadbang;
+#X floatatom 124 190 5 0 120 0 - - -;
+#X obj 124 295 route 0 1 2 3 4 5 6 7 8 9;
+#X obj 82 339 unpack 0 0 0 0;
+#X floatatom 82 461 5 0 0 0 - - -;
+#X floatatom 122 431 5 0 0 0 - - -;
+#X floatatom 162 406 5 0 0 0 - - -;
+#X obj 124 167 440;
+#X floatatom 203 380 5 0 0 0 - - -;
+#X obj 322 349 unpack 0 0 0 0;
+#X floatatom 322 471 5 0 0 0 - - -;
+#X floatatom 362 441 5 0 0 0 - - -;
+#X floatatom 402 416 5 0 0 0 - - -;
+#X floatatom 443 390 5 0 0 0 - - -;
+#X text 385 475 frequency (Hz.);
+#X text 419 442 peak amplitude (linear);
+#X text 464 416 cosine component;
+#X text 499 390 sine component;
+#X text 42 26 You can ask for sinusoidal peaks in decreasing order
+of amplitude or arranged into maximally continuous tracks for resynthesis.
+(Or you can ask for both.) In any case \, out come lists of five numbers
+\, one for each sinusoid at each analysis period. The first is the
+number of the sinusoid (so you can use "route" to claw them apart).
+The other four are as shown:;
+#X text 79 505 loudest partial;
+#X text 332 508 quietest partial;
+#X connect 0 0 4 0;
+#X connect 1 0 0 0;
+#X connect 2 0 9 0;
+#X connect 3 0 1 0;
+#X connect 4 0 5 0;
+#X connect 4 9 11 0;
+#X connect 5 0 6 0;
+#X connect 5 1 7 0;
+#X connect 5 2 8 0;
+#X connect 5 3 10 0;
+#X connect 9 0 3 0;
+#X connect 11 0 12 0;
+#X connect 11 1 13 0;
+#X connect 11 2 14 0;
+#X connect 11 3 15 0;
+#X restore 330 508 pd sinusoid-tracking;
+#X text 52 165 tracks - output sinusoidal peaks organized into tracks
+;
+#X text 56 111 notes - output pitch at the beginning of notes;
+#X text 339 485 more details:;
+#X text 10 184 Parameters you may set (in creation arguments or messages):
+;
+#X text 60 207 npts - number of points in each analysis window (1024)
+;
+#X text 60 225 hop - number of points between each analysis (512);
+#X text 60 242 npeak - number of sinusoidal peaks (20);
+#X text 61 279 vibrato - depth of vibrato to expect in 1/2-tones (1)
+;
+#X text 60 298 stabletime - time (msec) to wait to report notes (50)
+;
+#X obj 39 535 sigmund~ -hop 4096 pitch env;
+#X text 62 316 minpower - minimum power (dB) to report a pitch (50)
+;
+#X text 62 335 growth - growth (dB) to report a new note (7);
+#X text 54 147 peaks - output all sinusoidal peaks in order of amplitude
+;
+#X text 380 596 updated for Pd v0.40;
+#X text 11 356 The npts and hop parameters are in samples \, and are
+powers of two. The example below specifies a huge hop of 4096 (to slow
+the output down) and to output "pitch" and "env". (Those are the default
+outputs.);
+#X text 61 260 maxfreq - maximum sinusoid frequency in Hz. (1000000)
+;
+#X connect 2 0 25 0;
+#X connect 3 0 8 0;
+#X connect 4 0 7 0;
+#X connect 7 0 2 0;
+#X connect 8 0 4 0;
+#X connect 25 0 5 0;
+#X connect 25 1 6 0;
diff --git a/desiredata/extra/sigmund~/sigmund~.c b/desiredata/extra/sigmund~/sigmund~.c
new file mode 100644
index 00000000..96d15a2c
--- /dev/null
+++ b/desiredata/extra/sigmund~/sigmund~.c
@@ -0,0 +1,1333 @@
+/* Copyright (c) 2005 Miller Puckette.  BSD licensed.  No warranties. */
+
+/*
+    fix parameter settings
+    not to report pitch if evidence too scanty?
+    note-on detection triggered by falling envelope (a posteriori)
+    reentrancy bug setting loud flag (other parameters too?)
+    tweaked freqs still not stable enough
+    implement block ("-b") mode
+*/
+
+#include "m_pd.h"
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+#ifdef MSW
+#include <malloc.h>
+#else
+#include <alloca.h>
+#endif
+#include <stdlib.h>
+#ifdef NT
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4305 )
+#endif
+
+typedef struct peak
+{
+    float p_freq;
+    float p_amp;
+    float p_ampreal;
+    float p_ampimag;
+    float p_pit;
+    float p_db;
+    float p_salience;
+    float p_tmp;
+} t_peak;
+
+/********************** service routines **************************/
+
+static int sigmund_ilog2(int n)
+{
+    int ret = -1;
+    while (n)
+    {
+        n >>= 1;
+        ret++;
+    }
+    return (ret);
+}
+
+/* parameters for von Hann window (change these to get Hamming if desired) */
+#define W_ALPHA 0.5
+#define W_BETA 0.5
+#define NEGBINS 4   /* number of bins of negative frequency we'll need */
+
+#define PI 3.14159265
+#define LOG2  0.69314718
+#define LOG10 2.30258509
+
+static float sinx(float theta, float sintheta)
+{
+    if (theta > -0.003 && theta < 0.003)
+        return (1);
+    else return (sintheta/theta);
+}
+
+static float window_hann_mag(float pidetune, float sinpidetune)
+{
+    return (W_ALPHA * sinx(pidetune, sinpidetune)
+        - 0.5 * W_BETA *
+            (sinx(pidetune+PI, sinpidetune) + sinx(pidetune-PI, sinpidetune)));
+}
+
+static float window_mag(float pidetune, float cospidetune)
+{
+    return (sinx(pidetune + (PI/2), cospidetune)
+        + sinx(pidetune - (PI/2), -cospidetune));
+}
+
+/*********** Routines to analyze a window into sinusoidal peaks *************/
+
+static int sigmund_cmp_freq(const void *p1, const void *p2)
+{
+    if ((*(t_peak **)p1)->p_freq > (*(t_peak **)p2)->p_freq)
+        return (1);
+    else if ((*(t_peak **)p1)->p_freq < (*(t_peak **)p2)->p_freq)
+        return (-1);
+    else return (0);
+}
+
+static void sigmund_tweak(int npts, float *ftreal, float *ftimag,
+    int npeak, t_peak *peaks, float fperbin, int loud)
+{
+    t_peak **peakptrs = (t_peak **)alloca(sizeof (*peakptrs) * (npeak+1));
+    t_peak negpeak;
+    int peaki, j, k;
+    float ampreal[3], ampimag[3];
+    float binperf = 1./fperbin;
+    float phaseperbin = (npts-0.5)/npts, oneovern = 1./npts;
+    if (npeak < 1)
+        return;
+    for (peaki = 0; peaki < npeak; peaki++)
+        peakptrs[peaki+1] = &peaks[peaki];
+    qsort(peakptrs+1, npeak, sizeof (*peakptrs), sigmund_cmp_freq);
+    peakptrs[0] = &negpeak;
+    negpeak.p_ampreal = peakptrs[1]->p_ampreal;
+    negpeak.p_ampimag = -peakptrs[1]->p_ampimag;
+    negpeak.p_freq = -peakptrs[1]->p_freq;
+    for (peaki = 1; peaki <= npeak; peaki++)
+    {
+        int cbin = peakptrs[peaki]->p_freq*binperf + 0.5;
+        int nsub = (peaki == npeak ? 1:2);
+        float windreal, windimag, windpower, detune, pidetune, sinpidetune,
+            cospidetune, ampcorrect, ampout, ampoutreal, ampoutimag, freqout;
+        /* post("3 nsub %d amp %f freq %f", nsub,
+            peakptrs[peaki]->p_amp, peakptrs[peaki]->p_freq); */
+        if (cbin < 0 || cbin > 2*npts - 3)
+            continue;
+        for (j = 0; j < 3; j++)
+            ampreal[j] = ftreal[cbin+2*j-2], ampimag[j] = ftimag[cbin+2*j-2];
+        /* post("a %f %f", ampreal[1], ampimag[1]); */
+        for (j = 0; j < nsub; j++)
+        {
+            t_peak *neighbor = peakptrs[(peaki-1) + 2*j];
+            float neighborreal = npts * neighbor->p_ampreal;
+            float neighborimag = npts * neighbor->p_ampimag;
+            for (k = 0; k < 3; k++)
+            {
+                float freqdiff = (0.5*PI) * ((cbin + 2*k-2)
+                    -binperf * neighbor->p_freq);
+                float sx = sinx(freqdiff, sin(freqdiff));
+                float phasere = cos(freqdiff * phaseperbin);
+                float phaseim = sin(freqdiff * phaseperbin);
+                ampreal[k] -=
+                    sx * (phasere * neighborreal - phaseim * neighborimag);
+                ampimag[k] -=
+                    sx * (phaseim * neighborreal + phasere * neighborimag);
+            }       
+            /* post("b %f %f", ampreal[1], ampimag[1]); */
+        }
+
+        windreal = W_ALPHA * ampreal[1] -
+            (0.5 * W_BETA) * (ampreal[0] + ampreal[2]);
+        windimag = W_ALPHA * ampimag[1] -
+            (0.5 * W_BETA) * (ampimag[0] + ampimag[2]);
+        windpower = windreal * windreal + windimag * windimag;
+        detune = (
+            W_BETA*(ampreal[0] - ampreal[2]) * 
+                (2.0*W_ALPHA * ampreal[1] - W_BETA * (ampreal[0] + ampreal[2]))
+                    +
+            W_BETA*(ampimag[0] - ampimag[2]) *
+                (2.0*W_ALPHA * ampimag[1] - W_BETA * (ampimag[0] + ampimag[2]))
+                        ) / (4.0 * windpower);
+        if (detune > 0.5)
+            detune = 0.5;
+        else if (detune < -0.5)
+            detune = -0.5;
+        /* if (loud > 0)
+            post("tweak: windpower %f, bin %d, detune %f",
+                windpower, cbin, detune); */
+        pidetune = PI * detune;
+        sinpidetune = sin(pidetune);
+        cospidetune = cos(pidetune);
+
+        ampcorrect = 1.0 / window_hann_mag(pidetune, sinpidetune);
+
+        ampout = oneovern * ampcorrect *sqrt(windpower);
+        ampoutreal = oneovern * ampcorrect *
+            (windreal * cospidetune - windimag * sinpidetune);
+        ampoutimag = oneovern * ampcorrect *
+            (windreal * sinpidetune + windimag * cospidetune);
+        freqout = (cbin + 2*detune) * fperbin;
+        if (loud > 1)
+            post("amp %f, freq %f", ampout, freqout);
+        
+        peakptrs[peaki]->p_freq = freqout;
+        peakptrs[peaki]->p_amp = ampout;
+        peakptrs[peaki]->p_ampreal = ampoutreal;
+        peakptrs[peaki]->p_ampimag = ampoutimag;
+    }
+}
+
+
+static void sigmund_getrawpeaks(int npts, float *insamps,
+    int npeak, t_peak *peakv, int *nfound, float *power, float srate, int loud,
+    float param1, float param2, float param3, float hifreq)
+{
+    float oneovern = 1.0/ (float)npts;
+    float fperbin = 0.5 * srate * oneovern;
+    int npts2 = 2*npts, i, bin;
+    int count, peakcount = 0;
+    float *fp1, *fp2;
+    float *rawpow, *rawreal, *rawimag, *maskbuf;
+    float *bigbuf = alloca(sizeof (float ) * (2*NEGBINS + 5*npts));
+    int maxbin = hifreq/fperbin;
+    int altwind = (param3 == 1);
+    int tweak = (param3 == 0);
+    if (maxbin > npts - NEGBINS)
+        maxbin = npts - NEGBINS;
+    if (loud) post("tweak %d", tweak);
+    maskbuf = bigbuf + npts2;
+    rawreal = maskbuf + npts+NEGBINS;
+    rawimag = rawreal+npts+NEGBINS;
+    for (i = 0; i < npts; i++)
+        maskbuf[i] = 0;
+
+    for (i = 0; i < npts; i++)
+        bigbuf[i] = insamps[i];
+    for (i = npts; i < 2*npts; i++)
+        bigbuf[i] = 0;
+    mayer_realfft(npts2, bigbuf);
+    for (i = 0; i < npts; i++)
+        rawreal[i] = bigbuf[i];
+    for (i = 1; i < npts-1; i++)
+        rawimag[i] = bigbuf[npts2-i];
+    if (loud && npts == 1024)
+    {
+        float bigbuf2[2048];
+        for (i = 0; i < 1024; i++)
+            bigbuf2[i] = insamps[i];
+        for (i = 1024; i < 2048; i++)
+            bigbuf2[i] = 0;
+        mayer_realfft(2048, bigbuf2);
+        for (i = 1; i < 10; i++)
+            post("(%10.2f, %10.2f) -> (%10.2f, %10.2f)",
+                bigbuf2[i], bigbuf2[2048-i], rawreal[i], rawimag[i]);
+    }
+
+    rawreal[-1] = rawreal[1];
+    rawreal[-2] = rawreal[2];
+    rawreal[-3] = rawreal[3];
+    rawreal[-4] = rawreal[4];
+    rawimag[0] = rawimag[npts-1] = 0;
+    rawimag[-1] = -rawimag[1];
+    rawimag[-2] = -rawimag[2];
+    rawimag[-3] = -rawimag[3];
+    rawimag[-4] = -rawimag[4];
+
+    for (peakcount = 0; peakcount < npeak; peakcount++)
+    {
+        float pow1, maxpower = 0, totalpower = 0, windreal, windimag, windpower,
+            detune, pidetune, sinpidetune, cospidetune, ampcorrect, ampout,
+            ampoutreal, ampoutimag, freqout, freqcount1, freqcount2, powmask;
+        int bestindex = -1;
+        for (bin = 2, fp1 = rawreal+2, fp2 = rawimag+2;
+            bin < maxbin; bin++, fp1++, fp2++)
+        {
+            float x1, x2, a1, a2, b1, b2, thresh;
+            if (altwind)
+            {
+                x1 = fp1[0] - 0.5*(fp1[-2] +fp1[2]);
+                x2 = fp2[0] - 0.5*(fp2[-2] +fp2[2]);
+                a1 = fp1[4] - 0.5*(fp1[2] +fp1[6]);
+                a2 = fp2[2] - 0.5*(fp2[2] +fp2[6]);
+                b1 = fp1[-4] - 0.5*(fp1[-2] +fp1[-6]);
+                b2 = fp2[-4] - 0.5*(fp2[-2] +fp2[-6]);
+                thresh = param2 * (a1*a1+a2*a2+b1*b1+b2*b2);
+            }
+            else
+            {
+                x1 = fp1[1] - fp1[-1];
+                x2 = fp2[1] - fp2[-1];
+                a1 = fp1[3] - fp1[1];
+                a2 = fp2[3] - fp2[1];
+                b1 = fp1[-1] - fp1[-3];
+                b2 = fp2[-1] - fp2[-3];
+                thresh = param2 * (a1*a1+a2*a2+b1*b1+b2*b2);
+            }
+            pow1 = x1*x1+x2*x2;
+            if (pow1 > maxpower && pow1 > maskbuf[bin])
+            {
+                if (pow1 > thresh)
+                    maxpower = pow1, bestindex = bin;
+            }
+            totalpower += pow1;
+        }
+        if (totalpower <= 0 || maxpower < 1e-10*totalpower || bestindex < 0)
+            break;
+        fp1 = rawreal+bestindex;
+        fp2 = rawimag+bestindex;
+        *power = 0.5 * totalpower *oneovern * oneovern;
+        powmask = maxpower * exp(-param1 * log(10.) / 10.);
+        if (loud > 2)
+            post("maxpower %f, powmask %f, param1 %f",
+                maxpower, powmask, param1);
+        for (bin = 2; bin < maxbin; bin++)
+        {
+            float bindiff = bin - bestindex;
+            float mymask =
+                powmask/ (1. + bindiff * bindiff * bindiff * bindiff);
+            if (bindiff < 2 && bindiff > -2)
+                mymask = 2*maxpower;
+            if (mymask > maskbuf[bin])
+                maskbuf[bin] = mymask;
+        } 
+        
+        if (loud > 1)
+            post("best index %d, total power %f", bestindex, totalpower);
+        if (altwind)
+        {
+            windreal = W_ALPHA * fp1[0] - (0.5 * W_BETA) * (fp1[2] + fp1[-2]);
+            windimag = W_ALPHA * fp2[0] - (0.5 * W_BETA) * (fp2[2] + fp2[-2]);
+            windpower = windreal * windreal + windimag * windimag;
+            detune = (
+                (W_BETA*(rawreal[bestindex-2] - rawreal[bestindex+2])) *
+                (2.0 * W_ALPHA * rawreal[bestindex] - 
+                    W_BETA * (rawreal[bestindex-2] + rawreal[bestindex+2]))
+                        +
+                (W_BETA*(rawimag[bestindex-2] - rawimag[bestindex+2])) *
+                (2.0 * W_ALPHA * rawimag[bestindex] - 
+                    W_BETA * (rawimag[bestindex-2] + rawimag[bestindex+2]))
+                            ) / (4.0 * windpower);
+        }
+        else
+        {
+            windreal = fp1[1] - fp1[-1];
+            windimag = fp2[1] - fp2[-1];
+            windpower = windreal * windreal + windimag * windimag;
+            detune = ((fp1[1] * fp1[1] - fp1[-1]*fp1[-1]) 
+                + (fp2[1] * fp2[1] - fp2[-1]*fp2[-1])) / (2 * windpower);
+            if (loud > 2) post("(-1) %f %f; (1) %f %f",
+                fp1[-1], fp2[-1], fp1[1], fp2[1]);
+            if (loud > 2) post("peak %f %f",
+                fp1[0], fp2[0]);
+        }
+        if (detune > 0.5)
+            detune = 0.5;
+        else if (detune < -0.5)
+            detune = -0.5;
+        if (loud > 1)
+            post("windpower %f, index %d, detune %f",
+                windpower, bestindex, detune);
+        pidetune = PI * detune;
+        sinpidetune = sin(pidetune);
+        cospidetune = cos(pidetune);
+        if (altwind)
+            ampcorrect = 1.0 / window_hann_mag(pidetune, sinpidetune);
+        else ampcorrect = 1.0 / window_mag(pidetune, cospidetune);
+
+        ampout = ampcorrect *sqrt(windpower);
+        ampoutreal = ampcorrect *
+            (windreal * cospidetune - windimag * sinpidetune);
+        ampoutimag = ampcorrect *
+            (windreal * sinpidetune + windimag * cospidetune);
+
+            /* the frequency is the sum of the bin frequency and detuning */
+
+        peakv[peakcount].p_freq = (freqout = (bestindex + 2*detune)) * fperbin;
+        peakv[peakcount].p_amp = oneovern * ampout;
+        peakv[peakcount].p_ampreal = oneovern * ampoutreal;
+        peakv[peakcount].p_ampimag = oneovern * ampoutimag;
+    }
+    if (tweak)
+    {
+        sigmund_tweak(npts, rawreal, rawimag, peakcount, peakv, fperbin, loud);
+        sigmund_tweak(npts, rawreal, rawimag, peakcount, peakv, fperbin, loud);
+    }
+    for (i = 0; i < peakcount; i++)
+    {
+        peakv[i].p_pit = ftom(peakv[i].p_freq);
+        peakv[i].p_db = powtodb(peakv[i].p_amp);
+    }
+    *nfound = peakcount;
+}
+
+/*************** Routines for finding fundamental pitch *************/
+
+#define PITCHNPEAK 12
+#define PITCHUNCERTAINTY 0.3
+#define HALFTONEINC 0.059
+#define SUBHARMONICS 16
+#define DBPERHALFTONE 0.5
+
+static void sigmund_getpitch(int npeak, t_peak *peakv, float *freqp,
+    float npts, float srate, int loud)
+{
+    float fperbin = 0.5 * srate / npts;
+    int npit = 48 * sigmund_ilog2(npts), i, j, k, nsalient;
+    float bestbin, bestweight, sumamp, sumweight, sumfreq, sumallamp, 
+        freq;
+    float *weights =  (float *)alloca(sizeof(float) * npit);
+    t_peak *bigpeaks[PITCHNPEAK];
+    int nbigpeaks;
+    if (npeak < 1)
+    {
+        freq = 0;
+        goto done;
+    }
+    for (i = 0; i < npit; i++)
+        weights[i] = 0;
+    for (i = 0; i < npeak; i++)
+    {
+        peakv[i].p_tmp = 0;
+        peakv[i].p_salience = peakv[i].p_db - DBPERHALFTONE * peakv[i].p_pit;
+    }
+    for (nsalient = 0; nsalient < PITCHNPEAK; nsalient++)
+    {
+        t_peak *bestpeak = 0;
+        float bestsalience = -1e20;
+        for (j = 0; j < npeak; j++)
+            if (peakv[j].p_tmp == 0 && peakv[j].p_salience > bestsalience)
+        {
+            bestsalience = peakv[j].p_salience;
+            bestpeak = &peakv[j];
+        }
+        if (!bestpeak)
+            break;
+        bigpeaks[nsalient] = bestpeak;
+        bestpeak->p_tmp = 1;
+        /* post("peak f=%f a=%f", bestpeak->p_freq, bestpeak->p_amp); */
+    }
+    sumweight = 0;
+    for (i = 0; i < nsalient; i++)
+    {
+        t_peak *thispeak = bigpeaks[i];
+        float pitchuncertainty =
+            4 * PITCHUNCERTAINTY * fperbin / (HALFTONEINC * thispeak->p_freq);
+        float weightindex = (48./LOG2) *
+            log(thispeak->p_freq/(2.*fperbin));
+        float loudness = sqrt(thispeak->p_amp);
+        /* post("index %f, uncertainty %f", weightindex, pitchuncertainty); */
+        for (j = 0; j < SUBHARMONICS; j++)
+        {
+            float subindex = weightindex -
+                (48./LOG2) * log(j + 1.);
+            int loindex = subindex - pitchuncertainty;
+            int hiindex = subindex + pitchuncertainty + 1;
+            if (hiindex < 0)
+                break;
+            if (hiindex >= npit)
+                continue;
+            if (loindex < 0)
+                loindex = 0;
+            for (k = loindex; k <= hiindex; k++)
+                weights[k] += loudness * 4. / (4. + j);
+        }
+        sumweight += loudness;
+    }
+#if 0
+    for (i = 0; i < npit; i++)
+    {
+        postfloat(weights[i]);
+        if (!((i+1)%12)) post("");
+    }
+#endif
+    bestbin = -1;
+    bestweight = -1e20;
+    for (i = 0; i < npit; i++)
+        if (weights[i] > bestweight)
+            bestweight = weights[i], bestbin = i;
+    if (bestweight < sumweight * 0.4)
+        bestbin = -1;
+    
+    if (bestbin < 0)
+    {
+        freq = 0;
+        goto done;
+    }
+    for (i = bestbin+1; i < npit; i++)
+    {
+        if (weights[i] < bestweight)
+            break;
+        bestbin += 0.5;
+    }
+    freq = 2*fperbin * exp((LOG2/48.)*bestbin);
+
+    for (sumamp = sumweight = sumfreq = 0, i = 0; i < nsalient; i++)
+    {
+        t_peak *thispeak = bigpeaks[i];
+        float thisloudness = sqrt(thispeak->p_amp);
+        float thisfreq = thispeak->p_freq;
+        float harmonic = thisfreq/freq;
+        float intpart = (int)(0.5 + harmonic);
+        float inharm = freq * (harmonic - intpart);
+        if (harmonic < 1)
+            continue;
+        if (inharm < 0.25*fperbin && inharm > -0.25*fperbin)
+        {
+            float weight = thisloudness * intpart;
+            sumweight += weight;
+            sumfreq += weight*thisfreq/intpart;
+        }
+    }
+    if (sumweight > 0)
+        freq = sumfreq / sumweight;
+done:
+    if (!(freq >= 0 || freq <= 0))
+    {
+        post("freq nan cancelled");
+        freq = 0;
+    }
+    *freqp = freq;
+}
+
+/*************** gather peak lists into sinusoidal tracks *************/
+
+static void sigmund_peaktrack(int ninpeak, t_peak *inpeakv, 
+    int noutpeak, t_peak *outpeakv, int loud)
+{
+    int incnt, outcnt;
+    for (outcnt = 0; outcnt < noutpeak; outcnt++)
+        outpeakv[outcnt].p_tmp = -1;
+        
+        /* first pass. Match each "in" peak with the closest previous
+        "out" peak, but no two to the same one. */
+    for (incnt = 0; incnt < ninpeak; incnt++)
+    {
+        float besterror = 1e20;
+        int bestcnt = -1;
+        inpeakv[incnt].p_tmp = -1;
+        for (outcnt = 0; outcnt < noutpeak; outcnt++)
+        {
+            float thiserror =
+                inpeakv[incnt].p_freq - outpeakv[outcnt].p_freq;
+            if (thiserror < 0)
+                thiserror = -thiserror;
+            if (thiserror < besterror)
+            {
+                besterror = thiserror;
+                bestcnt = outcnt;
+            }
+        }
+        if (outpeakv[bestcnt].p_tmp < 0)
+        {
+            outpeakv[bestcnt] = inpeakv[incnt];
+            inpeakv[incnt].p_tmp = 0;
+            outpeakv[bestcnt].p_tmp = 0;
+        }
+    }
+        /* second pass.  Unmatched "in" peaks assigned to free "out"
+        peaks */
+    for (incnt = 0; incnt < ninpeak; incnt++)
+        if (inpeakv[incnt].p_tmp < 0)
+    {
+        for (outcnt = 0; outcnt < noutpeak; outcnt++)
+            if (outpeakv[outcnt].p_tmp < 0)
+        {
+            outpeakv[outcnt] = inpeakv[incnt];
+            inpeakv[incnt].p_tmp = 0;
+            outpeakv[outcnt].p_tmp = 1;
+            break;
+        }
+    }
+    for (outcnt = 0; outcnt < noutpeak; outcnt++)
+        if (outpeakv[outcnt].p_tmp == -1)
+            outpeakv[outcnt].p_amp = 0;
+}
+
+/**************** parse continuous pitch into note starts ***************/
+
+#define NHISTPOINT 100
+
+typedef struct _histpoint
+{
+    float h_freq;
+    float h_power;
+} t_histpoint;
+
+typedef struct _notefinder
+{
+    float n_age;
+    float n_hifreq;
+    float n_lofreq;
+    int n_peaked;
+    t_histpoint n_hist[NHISTPOINT];
+    int n_histphase;
+} t_notefinder;
+
+
+static void notefinder_init(t_notefinder *x)
+{
+    int i;
+    x->n_peaked = x->n_age = 0;
+    x->n_hifreq = x->n_lofreq = 0;
+    x->n_histphase = 0;
+    for (i = 0; i < NHISTPOINT; i++)
+        x->n_hist[i].h_freq =x->n_hist[i].h_power = 0;
+}
+
+static void notefinder_doit(t_notefinder *x, float freq, float power,
+    float *note, float vibrato, int stableperiod, float powerthresh,
+        float growththresh, int loud)
+{
+        /* calculate frequency ratio between allowable vibrato extremes
+        (equal to twice the vibrato deviation from center) */
+    float vibmultiple = exp((2*LOG2/12) * vibrato);
+    int oldhistphase, i, k;
+    if (stableperiod > NHISTPOINT - 1)
+        stableperiod = NHISTPOINT - 1;
+    if (++x->n_histphase == NHISTPOINT)
+        x->n_histphase = 0;
+    x->n_hist[x->n_histphase].h_freq = freq;
+    x->n_hist[x->n_histphase].h_power = power;
+    x->n_age++;
+    *note = 0;
+    if (loud)
+    {
+        post("stable %d, age %d, vibmultiple %f, powerthresh %f, hifreq %f",
+            stableperiod, (int)x->n_age ,vibmultiple, powerthresh, x->n_hifreq);
+        post("histfreq %f %f %f %f",
+            x->n_hist[x->n_histphase].h_freq,
+            x->n_hist[(x->n_histphase+NHISTPOINT-1)%NHISTPOINT].h_freq,
+            x->n_hist[(x->n_histphase+NHISTPOINT-2)%NHISTPOINT].h_freq,
+            x->n_hist[(x->n_histphase+NHISTPOINT-3)%NHISTPOINT].h_freq);
+        post("power %f %f %f %f",
+            x->n_hist[x->n_histphase].h_power,
+            x->n_hist[(x->n_histphase+NHISTPOINT-1)%NHISTPOINT].h_power,
+            x->n_hist[(x->n_histphase+NHISTPOINT-2)%NHISTPOINT].h_power,
+            x->n_hist[(x->n_histphase+NHISTPOINT-3)%NHISTPOINT].h_power);
+        for (i = 0, k = x->n_histphase; i < stableperiod; i++)
+        {
+            post("pit %5.1f  pow %f", ftom(x->n_hist[k].h_freq),
+                x->n_hist[k].h_power);
+            if (--k < 0)
+                k = NHISTPOINT - 1;
+        }
+    }
+       /* look for shorter notes than "stableperiod" in length.
+       The amplitude must rise and then fall while the pitch holds
+       steady. */
+    if (x->n_hifreq <= 0 && x->n_age > stableperiod)
+    {
+        float maxpow = 0, freqatmaxpow = 0,
+            localhifreq = -1e20, locallofreq = 1e20;
+        int startphase = x->n_histphase - stableperiod + 1;
+        if (startphase < 0)
+            startphase += NHISTPOINT;
+        for (i = 0, k = startphase; i < stableperiod; i++)
+        {
+            if (x->n_hist[k].h_freq <= 0)
+                break;
+            if (x->n_hist[k].h_power > maxpow)
+                maxpow = x->n_hist[k].h_power,
+                    freqatmaxpow = x->n_hist[k].h_freq;
+            if (x->n_hist[k].h_freq > localhifreq)
+                localhifreq = x->n_hist[k].h_freq;
+            if (x->n_hist[k].h_freq < locallofreq)
+                locallofreq = x->n_hist[k].h_freq;
+            if (localhifreq > locallofreq * vibmultiple)
+                break;
+            if (maxpow > power * growththresh &&
+                maxpow > x->n_hist[startphase].h_power * growththresh &&
+                    localhifreq < vibmultiple * locallofreq
+                        && freqatmaxpow > 0 && maxpow > powerthresh)
+            {
+                x->n_hifreq = x->n_lofreq = *note = freqatmaxpow;
+                x->n_age = 0;
+                x->n_peaked = 0;
+                /* post("got short note"); */
+                return;
+            }
+            if (++k >= NHISTPOINT)
+                k = 0;
+        }
+        
+    }
+    if (x->n_hifreq > 0)
+    {
+            /* test if we're within "vibrato" range, and if so update range */
+        if (freq * vibmultiple >= x->n_hifreq &&
+            x->n_lofreq * vibmultiple >= freq)
+        {
+            if (freq > x->n_hifreq)
+                x->n_hifreq = freq;
+            if (freq < x->n_lofreq)
+                x->n_lofreq = freq;
+        }
+        else if (x->n_hifreq > 0 && x->n_age > stableperiod)
+        {
+                /* if we've been out of range at least 1/2 the
+                last "stableperiod" analyses, clear the note */
+            int nbad = 0;
+            for (i = 0, k = x->n_histphase; i < stableperiod - 1; i++)
+            {
+                if (--k < 0)
+                    k = NHISTPOINT - 1;
+                if (x->n_hist[k].h_freq * vibmultiple <= x->n_hifreq ||
+                    x->n_lofreq * vibmultiple <= x->n_hist[k].h_freq)
+                        nbad++;
+            }
+            if (2 * nbad >= stableperiod)
+            {
+                x->n_hifreq = x->n_lofreq = 0;
+                x->n_age = 0;
+            }
+        }
+    }
+
+    oldhistphase = x->n_histphase - stableperiod;
+    if (oldhistphase < 0)
+        oldhistphase += NHISTPOINT;
+        
+        /* look for envelope attacks */
+
+    if (x->n_hifreq > 0 && x->n_peaked)
+    {
+        if (freq > 0 && power > powerthresh &&
+            power > x->n_hist[oldhistphase].h_power *
+                exp((LOG10*0.1)*growththresh))
+        {
+                /* clear it and fall through for new stable-note test */
+            x->n_peaked = 0;
+            x->n_hifreq = x->n_lofreq = 0;
+            x->n_age = 0;
+        }
+    }
+    else if (!x->n_peaked)
+    {
+        if (x->n_hist[oldhistphase].h_power > powerthresh &&
+            x->n_hist[oldhistphase].h_power > power)
+                x->n_peaked = 1;
+    }
+
+        /* test for a new note using a stability criterion. */
+
+    if (freq >= 0 &&
+        (x->n_hifreq <= 0 || freq > x->n_hifreq || freq < x->n_lofreq))
+    {
+        float testfhi, testflo, maxpow = 0;
+        for (i = 0, k = x->n_histphase, testfhi = testflo = freq;
+            i < stableperiod-1; i++)
+        {
+            if (--k < 0)
+                k = NHISTPOINT - 1;
+            if (x->n_hist[k].h_freq > testfhi)
+                testfhi = x->n_hist[k].h_freq;
+            if (x->n_hist[k].h_freq < testflo)
+                testflo = x->n_hist[k].h_freq;
+            if (x->n_hist[k].h_power > maxpow)
+                maxpow = x->n_hist[k].h_power;
+        }
+        if (testflo > 0 && testfhi <= vibmultiple * testflo
+            && maxpow > powerthresh)
+        {
+                /* report new note */
+            float sumf = 0, sumw = 0, thisf, thisw;
+            for (i = 0, k = x->n_histphase; i < stableperiod; i++)
+            {
+                thisw = x->n_hist[k].h_power;
+                sumw += thisw;
+                sumf += thisw*x->n_hist[k].h_freq;
+                if (--k < 0)
+                    k = NHISTPOINT - 1;
+            }
+            x->n_hifreq = x->n_lofreq = *note = (sumw > 0 ? sumf/sumw : 0);
+#if 0
+                /* debugging printout */
+            for (i = 0; i < stableperiod; i++)
+            {
+                int k3 = x->n_histphase - i;
+                if (k3 < 0)
+                    k3 += NHISTPOINT;
+                startpost("%5.1f ", ftom(x->n_hist[k3].h_freq));
+            }
+            post("");
+#endif
+            x->n_age = 0;
+            x->n_peaked = 0;
+            return;
+        }
+    }
+    *note = 0;
+    return;
+}
+
+/*************************** Glue for Pd ************************/
+
+static t_class *sigmund_class;
+#define NHIST 100
+
+#define MODE_STREAM 1
+#define MODE_BLOCK 2        /* uninplemented */
+#define MODE_TABLE 3
+
+#define NPOINTS_DEF 1024
+#define NPOINTS_MIN 128
+
+#define HOP_DEF 512
+#define NPEAK_DEF 20
+
+#define VIBRATO_DEF 1
+#define STABLETIME_DEF 50
+#define MINPOWER_DEF 50
+#define GROWTH_DEF 7
+
+#define OUT_PITCH 0
+#define OUT_ENV 1
+#define OUT_NOTE 2
+#define OUT_PEAKS 3
+#define OUT_TRACKS 4
+#define OUT_SMSPITCH 5
+#define OUT_SMSNONPITCH 6
+
+typedef struct _varout
+{
+    t_outlet *v_outlet;
+    int v_what;
+} t_varout;
+
+typedef struct _sigmund
+{
+    t_object x_obj;
+    t_varout *x_varoutv;
+    int x_nvarout;
+    t_clock *x_clock;
+    float x_f;          /* for main signal inlet */
+    float x_sr;         /* sample rate */
+    int x_mode;         /* MODE_STREAM, etc. */
+    int x_npts;         /* number of points in analysis window */
+    int x_npeak;        /* number of peaks to find */
+    int x_loud;         /* debug level */
+    t_sample *x_inbuf;  /* input buffer */
+    int x_infill;       /* number of points filled */
+    int x_countdown;    /* countdown to start filling buffer */
+    int x_hop;          /* samples between analyses */ 
+    float x_maxfreq;    /* highest-frequency peak to report */ 
+    float x_vibrato;    /* vibrato depth in half tones */ 
+    float x_stabletime; /* period of stability needed for note */ 
+    float x_growth;     /* growth to set off a new note */ 
+    float x_minpower;   /* minimum power, in DB, for a note */ 
+    float x_param1;
+    float x_param2;
+    float x_param3;
+    t_notefinder x_notefinder;
+    t_peak *x_trackv;
+    int x_ntrack;
+    unsigned int x_dopitch:1;
+    unsigned int x_donote:1;
+    unsigned int x_dotracks:1;
+} t_sigmund;
+
+static void sigmund_clock(t_sigmund *x);
+static void sigmund_clear(t_sigmund *x);
+static void sigmund_npts(t_sigmund *x, t_floatarg f);
+static void sigmund_hop(t_sigmund *x, t_floatarg f);
+static void sigmund_npeak(t_sigmund *x, t_floatarg f);
+static void sigmund_maxfreq(t_sigmund *x, t_floatarg f);
+static void sigmund_vibrato(t_sigmund *x, t_floatarg f);
+static void sigmund_stabletime(t_sigmund *x, t_floatarg f);
+static void sigmund_growth(t_sigmund *x, t_floatarg f);
+static void sigmund_minpower(t_sigmund *x, t_floatarg f);
+
+static void *sigmund_new(t_symbol *s, int argc, t_atom *argv)
+{
+    t_sigmund *x = (t_sigmund *)pd_new(sigmund_class);
+    x->x_param1 = 0;
+    x->x_param2 = 0.6;
+    x->x_param3 = 0;
+    x->x_npts = NPOINTS_DEF;
+    x->x_hop = HOP_DEF;
+    x->x_mode = MODE_STREAM;
+    x->x_npeak = NPEAK_DEF;
+    x->x_vibrato = VIBRATO_DEF;
+    x->x_stabletime = STABLETIME_DEF;
+    x->x_growth = GROWTH_DEF;
+    x->x_minpower = MINPOWER_DEF;
+    x->x_maxfreq = 1000000;
+    x->x_loud = 0;
+    x->x_sr = 1;
+    x->x_nvarout = 0;
+    x->x_varoutv = (t_varout *)getbytes(0);
+    x->x_trackv = 0;
+    x->x_ntrack = 0;
+    x->x_dopitch = x->x_donote = x->x_dotracks = 0;
+    
+    while (argc > 0)
+    {
+        t_symbol *firstarg = atom_getsymbolarg(0, argc, argv);
+        if (!strcmp(firstarg->s_name, "-t"))
+        {
+            x->x_mode = MODE_TABLE;
+            argc--, argv++;
+        }
+        else if (!strcmp(firstarg->s_name, "-s"))
+        {
+            x->x_mode = MODE_STREAM;
+            argc--, argv++;
+        }
+#if 0
+        else if (!strcmp(firstarg->s_name, "-b"))
+        {
+            x->x_mode = MODE_BLOCK;
+            argc--, argv++;
+        }
+#endif
+        else if (!strcmp(firstarg->s_name, "-npts") && argc > 1)
+        {
+            sigmund_npts(x, atom_getfloatarg(1, argc, argv));
+            argc -= 2; argv += 2;
+        }
+        else if (!strcmp(firstarg->s_name, "-hop") && argc > 1)
+        {
+            sigmund_hop(x, atom_getfloatarg(1, argc, argv));
+            argc -= 2; argv += 2;
+        }
+        else if (!strcmp(firstarg->s_name, "-npeak") && argc > 1)
+        {
+            sigmund_npeak(x, atom_getfloatarg(1, argc, argv));
+            argc -= 2; argv += 2;
+        }
+        else if (!strcmp(firstarg->s_name, "-maxfreq") && argc > 1)
+        {
+            sigmund_maxfreq(x, atom_getfloatarg(1, argc, argv));
+            argc -= 2; argv += 2;
+        }
+        else if (!strcmp(firstarg->s_name, "-vibrato") && argc > 1)
+        {
+            sigmund_vibrato(x, atom_getfloatarg(1, argc, argv));
+            argc -= 2; argv += 2;
+        }
+        else if (!strcmp(firstarg->s_name, "-stabletime") && argc > 1)
+        {
+            sigmund_stabletime(x, atom_getfloatarg(1, argc, argv));
+            argc -= 2; argv += 2;
+        }
+        else if (!strcmp(firstarg->s_name, "-growth") && argc > 1)
+        {
+            sigmund_growth(x, atom_getfloatarg(1, argc, argv));
+            argc -= 2; argv += 2;
+        }
+        else if (!strcmp(firstarg->s_name, "-minpower") && argc > 1)
+        {
+            sigmund_minpower(x, atom_getfloatarg(1, argc, argv));
+            argc -= 2; argv += 2;
+        }
+        else if (!strcmp(firstarg->s_name, "pitch"))
+        {
+            int n2 = x->x_nvarout+1;
+            x->x_varoutv = (t_varout *)t_resizebytes(x->x_varoutv,
+                x->x_nvarout*sizeof(t_varout), n2*sizeof(t_varout));
+            x->x_varoutv[x->x_nvarout].v_outlet =
+                outlet_new(&x->x_obj, &s_float);
+            x->x_varoutv[x->x_nvarout].v_what = OUT_PITCH;
+            x->x_nvarout = n2;
+            x->x_dopitch = 1;
+            argc--, argv++;
+        }
+        else if (!strcmp(firstarg->s_name, "env"))
+        {
+            int n2 = x->x_nvarout+1;
+            x->x_varoutv = (t_varout *)t_resizebytes(x->x_varoutv,
+                x->x_nvarout*sizeof(t_varout), n2*sizeof(t_varout));
+            x->x_varoutv[x->x_nvarout].v_outlet =
+                outlet_new(&x->x_obj, &s_float);
+            x->x_varoutv[x->x_nvarout].v_what = OUT_ENV;
+            x->x_nvarout = n2;
+            argc--, argv++;
+        }
+        else if (!strcmp(firstarg->s_name, "note")
+            || !strcmp(firstarg->s_name, "notes"))
+        {
+            int n2 = x->x_nvarout+1;
+            x->x_varoutv = (t_varout *)t_resizebytes(x->x_varoutv,
+                x->x_nvarout*sizeof(t_varout), n2*sizeof(t_varout));
+            x->x_varoutv[x->x_nvarout].v_outlet =
+                outlet_new(&x->x_obj, &s_float);
+            x->x_varoutv[x->x_nvarout].v_what = OUT_NOTE;
+            x->x_nvarout = n2;
+            x->x_dopitch = x->x_donote = 1;
+            argc--, argv++;
+        }
+        else if (!strcmp(firstarg->s_name, "peaks"))
+        {
+            int n2 = x->x_nvarout+1;
+            x->x_varoutv = (t_varout *)t_resizebytes(x->x_varoutv,
+                x->x_nvarout*sizeof(t_varout), n2*sizeof(t_varout));
+            x->x_varoutv[x->x_nvarout].v_outlet =
+                outlet_new(&x->x_obj, &s_list);
+            x->x_varoutv[x->x_nvarout].v_what = OUT_PEAKS;
+            x->x_nvarout = n2;
+            argc--, argv++;
+        }
+        else if (!strcmp(firstarg->s_name, "tracks"))
+        {
+            int n2 = x->x_nvarout+1;
+            x->x_varoutv = (t_varout *)t_resizebytes(x->x_varoutv,
+                x->x_nvarout*sizeof(t_varout), n2*sizeof(t_varout));
+            x->x_varoutv[x->x_nvarout].v_outlet =
+                outlet_new(&x->x_obj, &s_list);
+            x->x_varoutv[x->x_nvarout].v_what = OUT_TRACKS;
+            x->x_nvarout = n2;
+            x->x_dotracks = 1;
+            argc--, argv++;
+        }
+        else
+        {
+            pd_error(x, "sigmund: %s: unknown flag or argument missing",
+                firstarg->s_name);
+            argc--, argv++;
+        }
+    }
+    if (!x->x_nvarout)
+    {
+        x->x_varoutv = (t_varout *)t_resizebytes(x->x_varoutv,
+            0, 2*sizeof(t_varout));
+        x->x_varoutv[0].v_outlet = outlet_new(&x->x_obj, &s_float);
+        x->x_varoutv[0].v_what = OUT_PITCH;
+        x->x_varoutv[1].v_outlet = outlet_new(&x->x_obj, &s_float);
+        x->x_varoutv[1].v_what = OUT_ENV;
+        x->x_nvarout = 2;
+        x->x_dopitch = 1;
+    }
+    if (x->x_dotracks)
+    {
+        x->x_ntrack = x->x_npeak;
+        x->x_trackv = (t_peak *)getbytes(x->x_ntrack * sizeof(*x->x_trackv));
+    }
+    x->x_clock = clock_new(&x->x_obj.ob_pd, (t_method)sigmund_clock);
+    
+        /* check parameter ranges */
+    if (x->x_npts < NPOINTS_MIN)
+        post("sigmund~: minimum points %d", NPOINTS_MIN),
+            x->x_npts = NPOINTS_MIN;
+    if (x->x_npts != (1 << sigmund_ilog2(x->x_npts)))
+        post("sigmund~: adjusting analysis size to %d points",
+            (x->x_npts = (1 << sigmund_ilog2(x->x_npts))));
+    if (x->x_hop != (1 << sigmund_ilog2(x->x_hop)))
+        post("sigmund~: adjusting hop size to %d points",
+            (x->x_hop = (1 << sigmund_ilog2(x->x_hop))));
+    if (x->x_mode == MODE_STREAM)
+        x->x_inbuf = getbytes(sizeof(*x->x_inbuf) * x->x_npts);
+    else x->x_inbuf = 0;
+    x->x_infill = 0;
+    x->x_countdown = 0;
+    notefinder_init(&x->x_notefinder);
+    sigmund_clear(x);
+    return (x);
+}
+
+static void sigmund_doit(t_sigmund *x, int npts, float *arraypoints,
+    int loud, float srate)
+{
+    t_peak *peakv = (t_peak *)alloca(sizeof(t_peak) * x->x_npeak);
+    int nfound, i, cnt;
+    float freq = 0, power, note = 0;
+    sigmund_getrawpeaks(npts, arraypoints, x->x_npeak, peakv,
+        &nfound, &power, srate, loud, x->x_param1, x->x_param2, x->x_param3,
+        x->x_maxfreq);
+    if (x->x_dopitch)
+        sigmund_getpitch(nfound, peakv, &freq, npts, srate, loud);
+    if (x->x_donote)
+        notefinder_doit(&x->x_notefinder, freq, power, &note, x->x_vibrato, 
+            x->x_stabletime * 0.001f * x->x_sr / (float)x->x_hop,
+                exp(LOG10*0.1*(x->x_minpower - 100)), x->x_growth, loud);
+    if (x->x_dotracks)
+        sigmund_peaktrack(nfound, peakv, x->x_ntrack, x->x_trackv, loud);
+    
+    for (cnt = x->x_nvarout; cnt--;)
+    {
+        t_varout *v = &x->x_varoutv[cnt];
+        switch (v->v_what)
+        {
+        case OUT_PITCH:
+            outlet_float(v->v_outlet, ftom(freq));
+            break;
+        case OUT_ENV:
+            outlet_float(v->v_outlet, powtodb(power));
+            break;
+        case OUT_NOTE:
+            if (note > 0)
+                outlet_float(v->v_outlet, ftom(note));
+            break;
+        case OUT_PEAKS:
+            for (i = 0; i < nfound; i++)
+            {
+                t_atom at[5];
+                SETFLOAT(at, (float)i);
+                SETFLOAT(at+1, peakv[i].p_freq);
+                SETFLOAT(at+2, 2*peakv[i].p_amp);
+                SETFLOAT(at+3, 2*peakv[i].p_ampreal);
+                SETFLOAT(at+4, 2*peakv[i].p_ampimag);
+                outlet_list(v->v_outlet, &s_list, 5, at);   
+            }
+            break;
+        case OUT_TRACKS:
+            for (i = 0; i < x->x_ntrack; i++)
+            {
+                t_atom at[4];
+                SETFLOAT(at, (float)i);
+                SETFLOAT(at+1, x->x_trackv[i].p_freq);
+                SETFLOAT(at+2, 2*x->x_trackv[i].p_amp);
+                SETFLOAT(at+3, x->x_trackv[i].p_tmp);
+                outlet_list(v->v_outlet, &s_list, 4, at);   
+            }
+            break;
+        }
+    }
+}
+
+static void sigmund_list(t_sigmund *x, t_symbol *s, int argc, t_atom *argv)
+{
+    t_symbol *syminput = atom_getsymbolarg(0, argc, argv);
+    int npts = atom_getintarg(1, argc, argv);
+    int onset = atom_getintarg(2, argc, argv);
+    float srate = atom_getfloatarg(3, argc, argv);
+    int loud = atom_getfloatarg(4, argc, argv);
+    int arraysize, totstorage, nfound, i;
+    t_garray *a;
+    float *arraypoints, pit;
+    
+    if (argc < 5)
+    {
+        post(
+         "sigmund: array-name, npts, array-onset, samplerate, loud");
+        return;
+    }
+    if (npts < 64 || npts != (1 << ilog2(npts))) 
+    {
+        error("sigmund: bad npoints");
+        return;
+    }
+    if (onset < 0)
+    {
+        error("sigmund: negative onset");
+        return;
+    }
+    
+    if (!(a = (t_garray *)pd_findbyclass(syminput, garray_class)) ||
+        !garray_getfloatarray(a, &arraysize, &arraypoints) ||
+            arraysize < onset + npts)
+    {
+        error("%s: array missing or too small", syminput->s_name);
+        return;
+    }
+    if (arraysize < npts)
+    {
+        error("sigmund~: too few points in array");
+        return;
+    }
+    sigmund_doit(x, npts, arraypoints+onset, loud, srate);
+}
+
+static void sigmund_clear(t_sigmund *x)
+{
+    if (x->x_trackv)
+        memset(x->x_trackv, 0, x->x_ntrack * sizeof(*x->x_trackv));
+    x->x_infill = x->x_countdown = 0;
+}
+
+    /* these are for testing; their meanings vary... */
+static void sigmund_param1(t_sigmund *x, t_floatarg f)
+{
+    x->x_param1 = f;
+}
+
+static void sigmund_param2(t_sigmund *x, t_floatarg f)
+{
+    x->x_param2 = f;
+}
+
+static void sigmund_param3(t_sigmund *x, t_floatarg f)
+{
+    x->x_param3 = f;
+}
+
+static void sigmund_npts(t_sigmund *x, t_floatarg f)
+{
+    x->x_npts = f;
+        /* check parameter ranges */
+    if (x->x_npts < NPOINTS_MIN)
+        post("sigmund~: minimum points %d", NPOINTS_MIN),
+            x->x_npts = NPOINTS_MIN;
+    if (x->x_npts != (1 << sigmund_ilog2(x->x_npts)))
+        post("sigmund~: adjusting analysis size to %d points",
+            (x->x_npts = (1 << sigmund_ilog2(x->x_npts))));
+}
+
+static void sigmund_hop(t_sigmund *x, t_floatarg f)
+{
+    x->x_hop = f;
+        /* check parameter ranges */
+    if (x->x_hop != (1 << sigmund_ilog2(x->x_hop)))
+        post("sigmund~: adjusting analysis size to %d points",
+            (x->x_hop = (1 << sigmund_ilog2(x->x_hop))));
+}
+
+static void sigmund_npeak(t_sigmund *x, t_floatarg f)
+{
+    if (f < 1)
+        f = 1;
+    x->x_npeak = f;
+}
+
+static void sigmund_maxfreq(t_sigmund *x, t_floatarg f)
+{
+    x->x_maxfreq = f;
+}
+
+static void sigmund_vibrato(t_sigmund *x, t_floatarg f)
+{
+    if (f < 0)
+        f = 0;
+    x->x_vibrato = f;
+}
+
+static void sigmund_stabletime(t_sigmund *x, t_floatarg f)
+{
+    if (f < 0)
+        f = 0;
+    x->x_stabletime = f;
+}
+
+static void sigmund_growth(t_sigmund *x, t_floatarg f)
+{
+    if (f < 0)
+        f = 0;
+    x->x_growth = f;
+}
+
+static void sigmund_minpower(t_sigmund *x, t_floatarg f)
+{
+    if (f < 0)
+        f = 0;
+    x->x_minpower = f;
+}
+
+static void sigmund_print(t_sigmund *x)
+{
+    post("sigmund~ settings:");
+    post("npts %d", (int)x->x_npts);
+    post("hop %d", (int)x->x_hop);
+    post("npeak %d", (int)x->x_npeak);
+    post("maxfreq %g", x->x_maxfreq);
+    post("vibrato %g", x->x_vibrato);
+    post("stabletime %g", x->x_stabletime);
+    post("growth %g", x->x_growth);
+    post("minpower %g", x->x_minpower);
+}
+
+static void sigmund_printnext(t_sigmund *x, t_float f)
+{
+    x->x_loud = f;
+}
+
+static void sigmund_clock(t_sigmund *x)
+{
+    if (x->x_infill == x->x_npts)
+    {
+        sigmund_doit(x, x->x_npts, x->x_inbuf, x->x_loud, x->x_sr);
+        if (x->x_hop >= x->x_npts)
+        {
+            x->x_infill = 0;
+            x->x_countdown = x->x_hop - x->x_npts;
+        }
+        else
+        {
+            memmove(x->x_inbuf, x->x_inbuf + x->x_hop,
+                (x->x_infill = x->x_npts - x->x_hop) * sizeof(*x->x_inbuf));
+            x->x_countdown = 0;
+        }
+        x->x_loud = 0;
+    }
+}
+
+static t_int *sigmund_perform(t_int *w)
+{
+    t_sigmund *x = (t_sigmund *)(w[1]);
+    float *in = (float *)(w[2]);
+    int n = (int)(w[3]);
+
+    if (x->x_countdown > 0)
+        x->x_countdown -= n;
+    else if (x->x_infill != x->x_npts)
+    {
+        int i, j;
+        float *fp = x->x_inbuf + x->x_infill;
+        for (j = 0; j < n; j++)
+            *fp++ = *in++;
+        x->x_infill += n;
+        if (x->x_infill == x->x_npts)
+            clock_delay(x->x_clock, 0);
+    }
+    return (w+4);
+}
+
+static void sigmund_dsp(t_sigmund *x, t_signal **sp)
+{
+    if (x->x_mode == MODE_STREAM)
+    {
+        if (x->x_hop % sp[0]->s_n)
+            post("sigmund: adjusting hop size to %d",
+                (x->x_hop = sp[0]->s_n * (x->x_hop / sp[0]->s_n)));
+        x->x_sr = sp[0]->s_sr;
+        dsp_add(sigmund_perform, 3, x, sp[0]->s_vec, sp[0]->s_n);
+    }
+}
+
+static void sigmund_free(t_sigmund *x)
+{
+    if (x->x_inbuf)
+        freebytes(x->x_inbuf, x->x_npts * sizeof(*x->x_inbuf));
+    if (x->x_trackv)
+        freebytes(x->x_trackv, x->x_ntrack * sizeof(*x->x_trackv));
+    clock_free(x->x_clock);
+}
+
+void sigmund_tilde_setup(void)
+{
+    sigmund_class = class_new(gensym("sigmund~"), (t_newmethod)sigmund_new,
+        (t_method)sigmund_free, sizeof(t_sigmund), 0, A_GIMME, 0);
+    class_addlist(sigmund_class, sigmund_list);
+    class_addmethod(sigmund_class, (t_method)sigmund_dsp, gensym("dsp"), 0);
+    CLASS_MAINSIGNALIN(sigmund_class, t_sigmund, x_f);
+    class_addmethod(sigmund_class, (t_method)sigmund_param1,
+        gensym("param1"), A_FLOAT, 0);
+    class_addmethod(sigmund_class, (t_method)sigmund_param2,
+        gensym("param2"), A_FLOAT, 0);
+    class_addmethod(sigmund_class, (t_method)sigmund_param3,
+        gensym("param3"), A_FLOAT, 0);
+    class_addmethod(sigmund_class, (t_method)sigmund_npts,
+        gensym("npts"), A_FLOAT, 0);
+    class_addmethod(sigmund_class, (t_method)sigmund_hop,
+        gensym("hop"), A_FLOAT, 0);
+    class_addmethod(sigmund_class, (t_method)sigmund_maxfreq,
+        gensym("maxfreq"), A_FLOAT, 0);
+    class_addmethod(sigmund_class, (t_method)sigmund_npeak,
+        gensym("npeak"), A_FLOAT, 0);
+    class_addmethod(sigmund_class, (t_method)sigmund_vibrato,
+        gensym("vibrato"), A_FLOAT, 0);
+    class_addmethod(sigmund_class, (t_method)sigmund_stabletime,
+        gensym("stabletime"), A_FLOAT, 0);
+    class_addmethod(sigmund_class, (t_method)sigmund_growth,
+        gensym("growth"), A_FLOAT, 0);
+    class_addmethod(sigmund_class, (t_method)sigmund_minpower,
+        gensym("minpower"), A_FLOAT, 0);
+    class_addmethod(sigmund_class, (t_method)sigmund_print,
+        gensym("print"), 0);
+    class_addmethod(sigmund_class, (t_method)sigmund_printnext,
+        gensym("printnext"), A_FLOAT, 0);
+    post("sigmund version 0.02");
+}
+